-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A wrapper for gi-gtk, adding a few more idiomatic API parts on top
--   
--   A wrapper for gi-gtk, adding a few more idiomatic API parts on top
@package gi-gtk-hs
@version 0.3.16


-- | A module aimed at making working with GtkBuilder easier. It's meant to
--   be used like this (requires OverloadedStrings):
--   
--   <pre>
--   buildUI :: BuildFn ()
--   buildUI = do
--       mainWin &lt;- buildMainWin
--       buildAboutDialog
--   
--       widgetShowAll mainWin
--   
--   buildMainWin :: BuildFn ApplicationWindow
--   buildMainWin = do
--       buildHeaderBar
--       buildMenuBar
--       buildMainArea
--   
--       mainWin &lt;- getObject' ApplicationWindow "mainWin"
--       on mainWin Destroy mainQuit
--       return mainWin
--   
--   buildAboutDialog :: BuildFn AboutDialog
--   ...
--   
--   buildHeaderBar :: BuildFn HeaderBar
--   ...
--   
--   buildMenuBar :: BuildFn MenuBar
--   ...
--   
--   buildMainArea :: BuildFn Grid
--   ...
--   </pre>
module Data.GI.Gtk.BuildFn
type BuildFn a = ReaderT Builder IO a
buildWithBuilder :: MonadIO m => BuildFn a -> Builder -> m a
getObject :: GObject a => (ManagedPtr a -> a) -> Text -> BuildFn a


-- | Common types and classes for the ModelView modules.
module Data.GI.Gtk.ModelView.Types
newtype TypedTreeModel row
TypedTreeModel :: ManagedPtr (TypedTreeModel row) -> TypedTreeModel row
class IsTypedTreeModel model
toTypedTreeModel :: IsTypedTreeModel model => model row -> TypedTreeModel row
unsafeTreeModelToGeneric :: TreeModel -> model row
newtype TypedTreeModelSort row
TypedTreeModelSort :: ManagedPtr (TypedTreeModelSort row) -> TypedTreeModelSort row
unsafeTreeModelSortToGeneric :: TreeModelSort -> TypedTreeModelSort row
newtype TypedTreeModelFilter row
TypedTreeModelFilter :: ManagedPtr (TypedTreeModelFilter row) -> TypedTreeModelFilter row
unsafeTreeModelFilterToGeneric :: TreeModelFilter -> TypedTreeModelFilter row

-- | TreePath is a list of indices to specify a subtree or node in a
--   <a>TreeModel</a>. The node that correspond to a given <a>TreePath</a>
--   might change if nodes are removed or added and a <a>TreePath</a> may
--   refer to a different or even non-existent node after a modification of
--   the model. In contrast, a <a>TreeIter</a> is a more compact
--   representation of a <a>TreePath</a> which becomes invalid after each
--   modification of the underlying model. An intelligent index that is
--   adjusted with each update of the model to point to the same node
--   (whenever possible) is <a>TreeRowReference</a>.
treePathNewFromIndices' :: MonadIO m => [Int32] -> m TreePath
treePathGetIndices' :: MonadIO m => TreePath -> m [Int32]
withTreePath :: MonadIO m => [Int32] -> (TreePath -> m a) -> m a

-- | Convert a comma or colon separated string into a <a>TreePath</a>. Any
--   non-digit characters are assumed to separate indices, thus, the
--   function always is always successful.
stringToTreePath :: Text -> [Int32]
treeSelectionGetSelectedRows' :: (MonadIO m, IsTreeSelection sel) => sel -> m [TreePath]

-- | Accessing a row for a specific value. Used for <tt>ColumnMap</tt>.
data ColumnAccess row
[CAInvalid] :: ColumnAccess row
[CAInt] :: (row -> Int32) -> ColumnAccess row
[CABool] :: (row -> Bool) -> ColumnAccess row
[CAString] :: (row -> Text) -> ColumnAccess row
[CAPixbuf] :: (row -> Pixbuf) -> ColumnAccess row

-- | The type of a tree column.
data ColumnId row ty
ColumnId :: (GValue -> IO ty) -> ((row -> ty) -> ColumnAccess row) -> Int32 -> ColumnId row ty
comboQuark :: Word32
equalManagedPtr :: ManagedPtrNewtype a => a -> a -> Bool
instance Data.GI.Gtk.ModelView.Types.IsTypedTreeModel Data.GI.Gtk.ModelView.Types.TypedTreeModelFilter
instance Data.GI.Base.Overloading.HasParentTypes (Data.GI.Gtk.ModelView.Types.TypedTreeModelSort row)
instance Data.GI.Base.BasicTypes.TypedObject (Data.GI.Gtk.ModelView.Types.TypedTreeModelSort row)
instance Data.GI.Base.BasicTypes.GObject (Data.GI.Gtk.ModelView.Types.TypedTreeModelSort row)
instance Data.GI.Gtk.ModelView.Types.IsTypedTreeModel Data.GI.Gtk.ModelView.Types.TypedTreeModelSort
instance Data.GI.Gtk.ModelView.Types.IsTypedTreeModel Data.GI.Gtk.ModelView.Types.TypedTreeModel


-- | The tree interface used by <tt>TreeView</tt>.
module Data.GI.Gtk.ModelView.TreeModel

-- | Memory-managed wrapper type.
newtype () => TreeModel
TreeModel :: ManagedPtr TreeModel -> TreeModel

-- | Type class for types which can be safely cast to <a>TreeModel</a>, for
--   instance with <a>toTreeModel</a>.
class (GObject o, IsDescendantOf TreeModel o) => IsTreeModel o

-- | This signal is emitted when a new row has been inserted in the model.
--   
--   Note that the row may still be empty at this point, since it is a
--   common pattern to first insert an empty row, and then fill it with the
--   desired values.
type TreeModelRowInsertedCallback = TreePath -> TreeIter -> IO ()

-- | This signal is emitted when a row has gotten the first child row or
--   lost its last child row.
type TreeModelRowHasChildToggledCallback = TreePath -> TreeIter -> IO ()

-- | This signal is emitted when a row has been deleted.
--   
--   Note that no iterator is passed to the signal handler, since the row
--   is already deleted.
--   
--   This should be called by models after a row has been removed. The
--   location pointed to by <i><tt>path</tt></i> should be the location
--   that the row previously was at. It may not be a valid location
--   anymore.
type TreeModelRowDeletedCallback = TreePath -> IO ()

-- | This signal is emitted when a row in the model has changed.
type TreeModelRowChangedCallback = TreePath -> TreeIter -> IO ()
type family ResolveTreeModelMethod (t :: Symbol) o
data () => TreeModelFilterNewMethodInfo
data () => TreeModelForeachMethodInfo
data () => TreeModelGetColumnTypeMethodInfo
data () => TreeModelGetFlagsMethodInfo
data () => TreeModelGetIterFirstMethodInfo
data () => TreeModelGetIterFromStringMethodInfo
data () => TreeModelGetIterMethodInfo
data () => TreeModelGetNColumnsMethodInfo
data () => TreeModelGetPathMethodInfo
data () => TreeModelGetStringFromIterMethodInfo
data () => TreeModelGetValueMethodInfo
data () => TreeModelIterChildrenMethodInfo
data () => TreeModelIterHasChildMethodInfo
data () => TreeModelIterNChildrenMethodInfo
data () => TreeModelIterNextMethodInfo
data () => TreeModelIterNthChildMethodInfo
data () => TreeModelIterParentMethodInfo
data () => TreeModelIterPreviousMethodInfo
data () => TreeModelRefNodeMethodInfo
data () => TreeModelRowChangedMethodInfo
data () => TreeModelRowChangedSignalInfo
data () => TreeModelRowDeletedMethodInfo
data () => TreeModelRowDeletedSignalInfo
data () => TreeModelRowHasChildToggledMethodInfo
data () => TreeModelRowHasChildToggledSignalInfo
data () => TreeModelRowInsertedMethodInfo
data () => TreeModelRowInsertedSignalInfo
data () => TreeModelRowsReorderedMethodInfo
data () => TreeModelUnrefNodeMethodInfo

-- | Returns a set of flags supported by this interface.
--   
--   The flags are a bitwise combination of <a>TreeModelFlags</a>. The
--   flags supported should not change during the lifetime of the
--   <i><tt>treeModel</tt></i>.
treeModelGetFlags :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m [TreeModelFlags]

-- | Calls func on each node in model in a depth-first fashion.
--   
--   If <i><tt>func</tt></i> returns <a>True</a>, then the tree ceases to
--   be walked, and <a>treeModelForeach</a> returns.
treeModelForeach :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeModelForeachFunc -> m ()

-- | Lets the tree ref the node.
--   
--   This is an optional method for models to implement. To be more
--   specific, models may ignore this call as it exists primarily for
--   performance reasons.
--   
--   This function is primarily meant as a way for views to let caching
--   models know when nodes are being displayed (and hence, whether or not
--   to cache that node). Being displayed means a node is in an expanded
--   branch, regardless of whether the node is currently visible in the
--   viewport. For example, a file-system based model would not want to
--   keep the entire file-hierarchy in memory, just the sections that are
--   currently being displayed by every current view.
--   
--   A model should be expected to be able to get an iter independent of
--   its reffed state.
treeModelRefNode :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m ()

-- | Cast to <a>TreeModel</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeModel :: (MonadIO m, IsTreeModel o) => o -> m TreeModel

-- | Creates a new <a>TreeModel</a>, with <i><tt>childModel</tt></i> as the
--   child_model and <i><tt>root</tt></i> as the virtual root.
--   
--   <i>Since: 2.4</i>
treeModelFilterNew :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe TreePath -> m TreeModel

-- | Returns the type of the column.
treeModelGetColumnType :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Int32 -> m GType

-- | Initializes <i><tt>iter</tt></i> with the first iterator in the tree
--   (the one at the path "0") and returns <a>True</a>. Returns
--   <a>False</a> if the tree is empty.
treeModelGetIterFirst :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m (Bool, TreeIter)

-- | Sets <i><tt>iter</tt></i> to a valid iterator pointing to
--   <i><tt>pathString</tt></i>, if it exists. Otherwise,
--   <i><tt>iter</tt></i> is left invalid and <a>False</a> is returned.
treeModelGetIterFromString :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Text -> m (Bool, TreeIter)

-- | Returns the number of columns supported by <i><tt>treeModel</tt></i>.
treeModelGetNColumns :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m Int32

-- | Returns a newly-created <a>TreePath</a>-struct referenced by
--   <i><tt>iter</tt></i>.
--   
--   This path should be freed with <a>treePathFree</a>.
treeModelGetPath :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m TreePath

-- | Generates a string representation of the iter.
--   
--   This string is a “:” separated list of numbers. For example,
--   “4:10:0:3” would be an acceptable return value for this string.
--   
--   <i>Since: 2.2</i>
treeModelGetStringFromIter :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m Text

-- | Sets <i><tt>iter</tt></i> to point to the first child of
--   <i><tt>parent</tt></i>.
--   
--   If <i><tt>parent</tt></i> has no children, <a>False</a> is returned
--   and <i><tt>iter</tt></i> is set to be invalid. <i><tt>parent</tt></i>
--   will remain a valid node after this function has been called.
--   
--   If <i><tt>parent</tt></i> is <a>Nothing</a> returns the first node,
--   equivalent to <tt>gtk_tree_model_get_iter_first (tree_model,
--   iter);</tt>
treeModelIterChildren :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe TreeIter -> m (Bool, TreeIter)

-- | Returns <a>True</a> if <i><tt>iter</tt></i> has children, <a>False</a>
--   otherwise.
treeModelIterHasChild :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m Bool

-- | Returns the number of children that <i><tt>iter</tt></i> has.
--   
--   As a special case, if <i><tt>iter</tt></i> is <a>Nothing</a>, then the
--   number of toplevel nodes is returned.
treeModelIterNChildren :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe TreeIter -> m Int32

-- | Sets <i><tt>iter</tt></i> to point to the node following it at the
--   current level.
--   
--   If there is no next <i><tt>iter</tt></i>, <a>False</a> is returned and
--   <i><tt>iter</tt></i> is set to be invalid.
treeModelIterNext :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m Bool

-- | Sets <i><tt>iter</tt></i> to be the child of <i><tt>parent</tt></i>,
--   using the given index.
--   
--   The first index is 0. If <i><tt>n</tt></i> is too big, or
--   <i><tt>parent</tt></i> has no children, <i><tt>iter</tt></i> is set to
--   an invalid iterator and <a>False</a> is returned.
--   <i><tt>parent</tt></i> will remain a valid node after this function
--   has been called. As a special case, if <i><tt>parent</tt></i> is
--   <a>Nothing</a>, then the <i><tt>n</tt></i>-th root node is set.
treeModelIterNthChild :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe TreeIter -> Int32 -> m (Bool, TreeIter)

-- | Sets <i><tt>iter</tt></i> to be the parent of <i><tt>child</tt></i>.
--   
--   If <i><tt>child</tt></i> is at the toplevel, and doesn’t have a
--   parent, then <i><tt>iter</tt></i> is set to an invalid iterator and
--   <a>False</a> is returned. <i><tt>child</tt></i> will remain a valid
--   node after this function has been called.
--   
--   <i><tt>iter</tt></i> will be initialized before the lookup is
--   performed, so <i><tt>child</tt></i> and <i><tt>iter</tt></i> cannot
--   point to the same memory location.
treeModelIterParent :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m (Bool, TreeIter)

-- | Sets <i><tt>iter</tt></i> to point to the previous node at the current
--   level.
--   
--   If there is no previous <i><tt>iter</tt></i>, <a>False</a> is returned
--   and <i><tt>iter</tt></i> is set to be invalid.
--   
--   <i>Since: 3.0</i>
treeModelIterPrevious :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m Bool

-- | Emits the <a>TreeModel::rowChanged</a> signal on
--   <i><tt>treeModel</tt></i>.
treeModelRowChanged :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> TreeIter -> m ()

-- | Emits the <a>TreeModel::rowDeleted</a> signal on
--   <i><tt>treeModel</tt></i>.
--   
--   This should be called by models after a row has been removed. The
--   location pointed to by <i><tt>path</tt></i> should be the location
--   that the row previously was at. It may not be a valid location
--   anymore.
--   
--   Nodes that are deleted are not unreffed, this means that any
--   outstanding references on the deleted node should not be released.
treeModelRowDeleted :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> m ()

-- | Emits the <a>TreeModel::rowHasChildToggled</a> signal on
--   <i><tt>treeModel</tt></i>. This should be called by models after the
--   child state of a node changes.
treeModelRowHasChildToggled :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> TreeIter -> m ()

-- | Emits the <a>TreeModel::rowInserted</a> signal on
--   <i><tt>treeModel</tt></i>.
treeModelRowInserted :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> TreeIter -> m ()

-- | Emits the <a>TreeModel</a>::<tt><i>rows-reordered</i></tt> signal on
--   <i><tt>treeModel</tt></i>.
--   
--   This should be called by models when their rows have been reordered.
--   
--   <i>Since: 3.10</i>
treeModelRowsReordered :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> Maybe TreeIter -> [Int32] -> m ()

-- | Lets the tree unref the node.
--   
--   This is an optional method for models to implement. To be more
--   specific, models may ignore this call as it exists primarily for
--   performance reasons. For more information on what this means, see
--   <a>treeModelRefNode</a>.
--   
--   Please note that nodes that are deleted are not unreffed.
treeModelUnrefNode :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m ()

-- | Connect a signal handler for the <a>rowChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeModel #rowChanged callback
--   </pre>
onTreeModelRowChanged :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeModel #rowChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeModelRowChanged :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowDeleted</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeModel #rowDeleted callback
--   </pre>
onTreeModelRowDeleted :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowDeletedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowDeleted</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeModel #rowDeleted callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeModelRowDeleted :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowDeletedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowHasChildToggled</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeModel #rowHasChildToggled callback
--   </pre>
onTreeModelRowHasChildToggled :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowHasChildToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowHasChildToggled</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeModel #rowHasChildToggled callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeModelRowHasChildToggled :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowHasChildToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowInserted</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeModel #rowInserted callback
--   </pre>
onTreeModelRowInserted :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowInsertedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowInserted</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeModel #rowInserted callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeModelRowInserted :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowInsertedCallback) -> m SignalHandlerId

-- | The type of a tree column.
data ColumnId row ty

-- | Create a <a>ColumnId</a> to extract an integer.
makeColumnIdInt :: Int32 -> ColumnId row Int32

-- | Create a <a>ColumnId</a> to extract an Boolean.
makeColumnIdBool :: Int32 -> ColumnId row Bool

-- | Create a <a>ColumnId</a> to extract an string.
makeColumnIdString :: Int32 -> ColumnId row Text

-- | Create a <a>ColumnId</a> to extract an <a>Pixbuf</a>.
makeColumnIdPixbuf :: Int32 -> ColumnId row Pixbuf

-- | The invalid <a>ColumnId</a>. Widgets use this value if no column id
--   has been set.
invalidColumnId :: ColumnId row ty

-- | Convert a <a>ColumnId</a> to a bare number.
columnIdToNumber :: ColumnId row ty -> Int32

-- | Convert a comma or colon separated string into a <a>TreePath</a>. Any
--   non-digit characters are assumed to separate indices, thus, the
--   function always is always successful.
stringToTreePath :: Text -> [Int32]

-- | Read the value of at a specific column and <a>TreeIter</a>.
treeModelGetValue :: IsTreeModel self => self -> TreeIter -> ColumnId row ty -> IO ty

-- | Gets the a <a>TreeIter</a> or Nothing if the path is invalid or empty
treeModelGetIter :: (MonadIO m, IsTreeModel model) => model -> TreePath -> m (Maybe TreeIter)
instance GHC.Classes.Eq (Data.GI.Gtk.ModelView.Types.ColumnId row ty)
instance GHC.Show.Show (Data.GI.Gtk.ModelView.Types.ColumnId row ty)


-- | Allows a custom data structure to be used with the <tt>TreeView</tt>
--   and other widgets that follow the model-view-controller paradigm. The
--   two models <a>ListStore</a> and <a>TreeStore</a> are based on the
--   <a>CustomStore</a>. Even if no application-specific tree model should
--   be implemented, this module is relevant in that it provides the
--   functions <a>customStoreSetColumn</a> and <a>customStoreGetRow</a>
--   functions.
module Data.GI.Gtk.ModelView.CustomStore

-- | A <a>CustomStore</a> is an instance of a Gtk+ <a>TreeModel</a> and can
--   thus be used for any widget that stores data in a <a>TreeModel</a>.
--   The user may either create an instance of a <a>CustomStore</a> or use
--   one of the pre-defined models <a>ListStore</a> or <a>TreeStore</a>.
newtype CustomStore private row
CustomStore :: ManagedPtr (CustomStore private row) -> CustomStore private row

-- | These flags indicate various properties of a <a>TreeModel</a>.
--   
--   They are returned by <a>treeModelGetFlags</a>, and must be static for
--   the lifetime of the object. A more complete description of
--   <tt><i>GTK_TREE_MODEL_ITERS_PERSIST</i></tt> can be found in the
--   overview of this section.
data () => TreeModelFlags

-- | iterators survive all signals emitted by the tree
TreeModelFlagsItersPersist :: TreeModelFlags

-- | the model is a list only, and never has children
TreeModelFlagsListOnly :: TreeModelFlags

-- | Catch-all for unknown values
AnotherTreeModelFlags :: Int -> TreeModelFlags

-- | The <a>TreeModelIface</a> structure contains all functions that are
--   required to implement an application-specific <a>TreeModel</a>.
data TreeModelIface row
TreeModelIface :: IO [TreeModelFlags] -> (TreePath -> IO (Maybe TreeIter)) -> (TreeIter -> IO TreePath) -> (TreeIter -> IO row) -> (TreeIter -> IO (Maybe TreeIter)) -> (Maybe TreeIter -> IO (Maybe TreeIter)) -> (TreeIter -> IO Bool) -> (Maybe TreeIter -> IO Int) -> (Maybe TreeIter -> Int -> IO (Maybe TreeIter)) -> (TreeIter -> IO (Maybe TreeIter)) -> (TreeIter -> IO ()) -> (TreeIter -> IO ()) -> TreeModelIface row

-- | Return the flags that are valid for this model.
[treeModelIfaceGetFlags] :: TreeModelIface row -> IO [TreeModelFlags]

-- | Convert an path into the tree into a more concise <a>TreeIter</a>.
--   Return <tt>Nothing</tt> if the path does not exit.
[treeModelIfaceGetIter] :: TreeModelIface row -> TreePath -> IO (Maybe TreeIter)

-- | Convert an iterator to a path. The iterator will always be valid.
[treeModelIfaceGetPath] :: TreeModelIface row -> TreeIter -> IO TreePath

-- | Retrieve a row at the given iterator.
[treeModelIfaceGetRow] :: TreeModelIface row -> TreeIter -> IO row

-- | Advance the given iterator to the next node at the same level. Return
--   <tt>Nothing</tt> if there is no next node at this level.
[treeModelIfaceIterNext] :: TreeModelIface row -> TreeIter -> IO (Maybe TreeIter)

-- | Advance the given iterator to the first child of this iterator. Return
--   <tt>Notihing</tt> if the node at this iterator has no children.
[treeModelIfaceIterChildren] :: TreeModelIface row -> Maybe TreeIter -> IO (Maybe TreeIter)

-- | Check if the node at the given iterator has children.
[treeModelIfaceIterHasChild] :: TreeModelIface row -> TreeIter -> IO Bool

-- | Query the number of children the the node at the given iteratore has.
[treeModelIfaceIterNChildren] :: TreeModelIface row -> Maybe TreeIter -> IO Int

-- | Ask for an iterator to the <tt>n</tt>th child. Return <tt>Nothing</tt>
--   if no such child exists.
[treeModelIfaceIterNthChild] :: TreeModelIface row -> Maybe TreeIter -> Int -> IO (Maybe TreeIter)

-- | Ask for an iterator to the parent of the node.
[treeModelIfaceIterParent] :: TreeModelIface row -> TreeIter -> IO (Maybe TreeIter)

-- | Increase a reference count for this node. A positive reference count
--   indicates that the node is used (that is, most likely it is visible)
--   in at least one widget. Tracking reference counts for nodes is
--   optional but may be useful to infer when a given row can be discarded
--   if it was retrieved from an external source.
[treeModelIfaceRefNode] :: TreeModelIface row -> TreeIter -> IO ()

-- | Decrement the reference count of the given node.
[treeModelIfaceUnrefNode] :: TreeModelIface row -> TreeIter -> IO ()

-- | A structure containing functions that enable this widget to be used as
--   a source in drag-and-drop.
data DragSourceIface model row
DragSourceIface :: (model row -> TreePath -> IO Bool) -> (model row -> TreePath -> SelectionData -> IO Bool) -> (model row -> TreePath -> IO Bool) -> DragSourceIface model row

-- | Determine if the row at the given path is draggable. Return
--   <tt>False</tt> if for some reason this row should not be dragged by
--   the user.
[customDragSourceRowDraggable] :: DragSourceIface model row -> model row -> TreePath -> IO Bool

-- | Fill in the <a>SelectionData</a> structure with information on the
--   given node using <a>selectionDataSet</a>.
[customDragSourceDragDataGet] :: DragSourceIface model row -> model row -> TreePath -> SelectionData -> IO Bool

-- | The widget is informed that the row at the given path should be
--   deleted as the result of this drag.
[customDragSourceDragDataDelete] :: DragSourceIface model row -> model row -> TreePath -> IO Bool

-- | A structure containing functions that enable this widget to be used as
--   a target in drag-and-drop.
data DragDestIface model row
DragDestIface :: (model row -> TreePath -> SelectionData -> IO Bool) -> (model row -> TreePath -> SelectionData -> IO Bool) -> DragDestIface model row

-- | Tell the drag-and-drop mechanism if the row can be dropped at the
--   given path.
[customDragDestRowDropPossible] :: DragDestIface model row -> model row -> TreePath -> SelectionData -> IO Bool

-- | The data in the <tt>SelectionDataM</tt> structure should be read using
--   <a>selectionDataGet</a> and its information be used to insert a new
--   row at the given path.
[customDragDestDragDataReceived] :: DragDestIface model row -> model row -> TreePath -> SelectionData -> IO Bool

-- | Create a new store that implements the <a>TreeModelIface</a> interface
--   and optionally the <a>DragSourceIface</a> and the
--   <a>DragDestIface</a>. If the latter two are set to <tt>Nothing</tt> a
--   dummy interface is substituted that rejects every drag and drop.
customStoreNew :: (MonadIO m, IsTreeModel (model row), IsTypedTreeModel model) => private -> (CustomStore private row -> model row) -> TreeModelIface row -> Maybe (DragSourceIface model row) -> Maybe (DragDestIface model row) -> m (model row)

-- | Extract a row of the given model at the given <a>TreeIter</a>.
customStoreGetRow :: (MonadIO m, IsTypedTreeModel model) => model row -> TreeIter -> m row

-- | Set or update a column mapping. This function should be used before
--   the model is installed into a widget since the number of defined
--   columns are only checked once by widgets.
customStoreSetColumn :: (MonadIO m, IsTypedTreeModel model) => model row -> ColumnId row ty -> (row -> ty) -> m ()

-- | Return the private data stored in this <a>CustomStore</a>. The private
--   data is meant as a container for the data stored in this model.
customStoreGetPrivate :: CustomStore private row -> private

-- | Query the current value of the stamp that is used to create
--   <a>TreeIter</a> iterators. The stamp is compared each time a view
--   accesses this store. If the stamp doesn't match, a warning is emitted.
--   The stamp should be updated each time a the data in the model changes.
--   The rationale is that a view should never use a stale <a>TreeIter</a>,
--   i.e., one that refers to an old model.
customStoreGetStamp :: MonadIO m => CustomStore private row -> m Int32

-- | Create a new stamp. See <a>customStoreGetStamp</a>.
customStoreInvalidateIters :: MonadIO m => CustomStore private row -> m ()
instance Data.GI.Base.Overloading.HasParentTypes (Data.GI.Gtk.ModelView.CustomStore.CustomStore private row)
instance Data.GI.Base.BasicTypes.TypedObject (Data.GI.Gtk.ModelView.CustomStore.CustomStore private row)
instance Data.GI.Base.BasicTypes.GObject (Data.GI.Gtk.ModelView.CustomStore.CustomStore private row)


-- | Standard model to store list data.
module Data.GI.Gtk.ModelView.SeqStore
newtype SeqStore a
SeqStore :: ManagedPtr (CustomStore (IORef (Seq a)) a) -> SeqStore a

-- | Create a new <a>TreeModel</a> that contains a list of elements.
seqStoreNew :: (Applicative m, MonadIO m) => [a] -> m (SeqStore a)

-- | Create a new <a>TreeModel</a> that contains a list of elements. In
--   addition, specify two interfaces for drag and drop.
seqStoreNewDND :: (Applicative m, MonadIO m) => [a] -> Maybe (DragSourceIface SeqStore a) -> Maybe (DragDestIface SeqStore a) -> m (SeqStore a)

-- | Default drag functions for <a>SeqStore</a>. These functions allow the
--   rows of the model to serve as drag source. Any row is allowed to be
--   dragged and the data set in the <tt>SelectionDataM</tt> object is set
--   with <a>treeSetRowDragData</a>, i.e. it contains the model and the
--   <tt>TreePath</tt> to the row.
seqStoreDefaultDragSourceIface :: DragSourceIface SeqStore row

-- | Default drop functions for <a>SeqStore</a>. These functions accept a
--   row and insert the row into the new location if it is dragged into a
--   tree view that uses the same model.
seqStoreDefaultDragDestIface :: DragDestIface SeqStore row

-- | Convert a <tt>TreeIterRaw</tt> to an an index into the
--   <a>SeqStore</a>. Note that this function merely extracts the second
--   element of the <tt>TreeIterRaw</tt>.
seqStoreIterToIndex :: (Applicative m, MonadIO m) => TreeIter -> m Int32

-- | Extract the value at the given index.
seqStoreGetValue :: (Applicative m, MonadIO m) => SeqStore a -> Int32 -> m a

-- | Extract the value at the given index.
seqStoreSafeGetValue :: MonadIO m => SeqStore a -> Int32 -> m (Maybe a)

-- | Update the value at the given index. The index must exist.
seqStoreSetValue :: MonadIO m => SeqStore a -> Int32 -> a -> m ()

-- | Extract all data from the store.
seqStoreToList :: (Applicative m, MonadIO m) => SeqStore a -> m [a]

-- | Query the number of elements in the store.
seqStoreGetSize :: (Applicative m, MonadIO m) => SeqStore a -> m Int32

-- | Insert an element in front of the given element. The element is
--   appended if the index is greater or equal to the size of the list.
seqStoreInsert :: MonadIO m => SeqStore a -> Int32 -> a -> m ()

-- | Insert an element in front of the given element.
seqStoreInsertBefore :: (Applicative m, MonadIO m) => SeqStore a -> TreeIter -> a -> m ()

-- | Insert an element after the given element.
seqStoreInsertAfter :: (Applicative m, MonadIO m) => SeqStore a -> TreeIter -> a -> m ()

-- | Prepend the element to the store.
seqStorePrepend :: (Applicative m, MonadIO m) => SeqStore a -> a -> m ()

-- | Append an element to the store. Returns the index of the inserted
--   element.
seqStoreAppend :: MonadIO m => SeqStore a -> a -> m Int32

-- | Remove the element at the given index.
seqStoreRemove :: MonadIO m => SeqStore a -> Int32 -> m ()

-- | Empty the store.
seqStoreClear :: MonadIO m => SeqStore a -> m ()
instance Data.GI.Base.Overloading.HasParentTypes (Data.GI.Gtk.ModelView.SeqStore.SeqStore a)
instance Data.GI.Base.BasicTypes.TypedObject (Data.GI.Gtk.ModelView.SeqStore.SeqStore a)
instance Data.GI.Base.BasicTypes.GObject (Data.GI.Gtk.ModelView.SeqStore.SeqStore a)
instance Data.GI.Gtk.ModelView.Types.IsTypedTreeModel Data.GI.Gtk.ModelView.SeqStore.SeqStore


-- | Standard model to store hierarchical data.
module Data.GI.Gtk.ModelView.ForestStore

-- | A store for hierarchical data.
newtype ForestStore a
ForestStore :: ManagedPtr (CustomStore (IORef (Store a)) a) -> ForestStore a

-- | Create a new list store.
--   
--   <ul>
--   <li>The given rose tree determines the initial content and may be the
--   empty list. Each <a>Tree</a> in the forest corresponds to one
--   top-level node.</li>
--   <li>The ForestStore maintains the initially given Forest and aligns
--   the <a>TreePath</a> bits to fit in 96-bit length <a>TreeIter</a>
--   storage.</li>
--   <li>Additionally, a cache is used to achieve higher performance if
--   operating on recently used TreePaths.</li>
--   <li><b>Note:</b> due to the limited amount of bits available in
--   TreeIter storage, only limited depth forests can be used with this
--   implementation, the result of too deep Forests is an undefined
--   behaviour while trying to retrieve the deeply nested nodes. For
--   example: assuming the average requiement is 8 bits per tree level (max
--   number of children at the level is 255), then we can only use 12
--   levels deep trees (96/8) - any further levels in a TreePath will not
--   be encoded in the corresponding TreeIter storage.</li>
--   </ul>
forestStoreNew :: MonadIO m => Forest a -> m (ForestStore a)

-- | Create a new list store.
--   
--   <ul>
--   <li>In addition to <a>forestStoreNew</a>, this function takes an two
--   interfaces to implement user-defined drag-and-drop functionality.</li>
--   </ul>
forestStoreNewDND :: MonadIO m => Forest a -> Maybe (DragSourceIface ForestStore a) -> Maybe (DragDestIface ForestStore a) -> m (ForestStore a)

-- | Default drag functions for <a>ForestStore</a>. These functions allow
--   the rows of the model to serve as drag source. Any row is allowed to
--   be dragged and the data set in the <tt>SelectionDataM</tt> object is
--   set with <a>treeSetRowDragData</a>, i.e. it contains the model and the
--   <a>TreePath</a> to the row.
forestStoreDefaultDragSourceIface :: DragSourceIface ForestStore row

-- | Default drop functions for <a>ForestStore</a>. These functions accept
--   a row and insert the row into the new location if it is dragged into a
--   tree view that uses the same model.
forestStoreDefaultDragDestIface :: DragDestIface ForestStore row

-- | Extract one node from the current model. Fails if the given
--   <a>TreePath</a> refers to a non-existent node.
forestStoreGetValue :: (Applicative m, MonadIO m) => ForestStore a -> TreePath -> m a

-- | Extract a subtree from the current model. Fails if the given
--   <a>TreePath</a> refers to a non-existent node.
forestStoreGetTree :: MonadIO m => ForestStore a -> TreePath -> m (Tree a)

-- | Extract the forest from the current model.
forestStoreGetForest :: MonadIO m => ForestStore a -> m (Forest a)

-- | Extract a subtree from the current model. Like
--   <a>forestStoreGetTree</a> but returns <tt>Nothing</tt> if the path
--   refers to a non-existant node.
forestStoreLookup :: MonadIO m => ForestStore a -> TreePath -> m (Maybe (Tree a))

-- | Set a node in the store.
forestStoreSetValue :: MonadIO m => ForestStore a -> TreePath -> a -> m ()

-- | Insert a single node into the store.
--   
--   <ul>
--   <li>This function inserts a single node without children into the
--   tree. Its arguments are similar to those of
--   <a>forestStoreInsert</a>.</li>
--   </ul>
forestStoreInsert :: MonadIO m => ForestStore a -> TreePath -> Int -> a -> m ()

-- | Insert a node into the store.
forestStoreInsertTree :: MonadIO m => ForestStore a -> TreePath -> Int -> Tree a -> m ()

-- | Insert nodes into the store.
--   
--   <ul>
--   <li>The given list of nodes is inserted into given parent at
--   <tt>pos</tt>. If the parent existed, the function returns <tt>Just
--   path</tt> where <tt>path</tt> is the position of the newly inserted
--   elements. If <tt>pos</tt> is negative or greater or equal to the
--   number of children of the node at <tt>path</tt>, the new nodes are
--   appended to the list.</li>
--   </ul>
forestStoreInsertForest :: MonadIO m => ForestStore a -> TreePath -> Int -> Forest a -> m ()

-- | Remove a node from the store.
--   
--   <ul>
--   <li>The node denoted by the path is removed, along with all its
--   children. The function returns <tt>True</tt> if the given node was
--   found.</li>
--   </ul>
forestStoreRemove :: MonadIO m => ForestStore a -> TreePath -> m Bool
forestStoreClear :: MonadIO m => ForestStore a -> m ()

-- | Change a node in the store.
--   
--   <ul>
--   <li>Returns <tt>True</tt> if the node was found. For a monadic
--   version, see <a>forestStoreChangeM</a>.</li>
--   </ul>
forestStoreChange :: MonadIO m => ForestStore a -> TreePath -> (a -> a) -> m Bool

-- | Change a node in the store.
--   
--   <ul>
--   <li>Returns <tt>True</tt> if the node was found. For a purely
--   functional version, see <a>forestStoreChange</a>.</li>
--   </ul>
forestStoreChangeM :: MonadIO m => ForestStore a -> TreePath -> (a -> m a) -> m Bool
instance Data.GI.Base.Overloading.HasParentTypes (Data.GI.Gtk.ModelView.ForestStore.ForestStore a)
instance Data.GI.Base.BasicTypes.TypedObject (Data.GI.Gtk.ModelView.ForestStore.ForestStore a)
instance Data.GI.Base.BasicTypes.GObject (Data.GI.Gtk.ModelView.ForestStore.ForestStore a)
instance Data.GI.Gtk.ModelView.Types.IsTypedTreeModel Data.GI.Gtk.ModelView.ForestStore.ForestStore


-- | An interface for packing cells
--   
--   <ul>
--   <li>Module available since Gtk+ version 2.4</li>
--   </ul>
module Data.GI.Gtk.ModelView.CellLayout

-- | Adds an attribute mapping to the renderer <tt>cell</tt>. The
--   <tt>column</tt> is the <a>ColumnId</a> of the model to get a value
--   from, and the <tt>attribute</tt> is the parameter on <tt>cell</tt> to
--   be set from the value. So for example if column 2 of the model
--   contains strings, you could have the "text" attribute of a
--   <tt>CellRendererText</tt> get its values from column 2.
--   
--   cellLayoutAddColumnAttribute :: (MonadIO m, IsCellLayout self,
--   IsCellRenderer cell) =&gt; self -&gt; cell -- ^ <tt>cell</tt> - A
--   <a>CellRenderer</a>. -&gt; ReadWriteAttr cell a v -- ^
--   <tt>attribute</tt> - An attribute of a renderer. -&gt; ColumnId row v
--   -- ^ <tt>column</tt> - The virtual column of the model from which to
--   -- retrieve the attribute. -&gt; m () cellLayoutAddColumnAttribute
--   self cell attr column = cellLayoutAddAttribute self cell (T.pack $
--   show attr) (columnIdToNumber column)
--   
--   Specify how a row of the <tt>model</tt> defines the attributes of the
--   <a>CellRenderer</a> <tt>cell</tt>. This is a convenience wrapper
--   around <tt>cellLayoutSetAttributeFunc</tt> in that it sets the cells
--   of the <tt>cell</tt> with the data retrieved from the model.
--   
--   <ul>
--   <li>Note on using <a>TreeModelSort</a> and <a>TreeModelFilter</a>:
--   These two models wrap another model, the so-called child model,
--   instead of storing their own data. This raises the problem that the
--   data of cell renderers must be set using the child model, while the
--   <a>TreeIter</a>s that the view works with refer to the model that
--   encapsulates the child model. For convenience, this function
--   transparently translates an iterator to the child model before
--   extracting the data using e.g.
--   <a>treeModelSortConvertIterToChildIter</a>. Hence, it is possible to
--   install the encapsulating model in the view and to pass the child
--   model to this function.</li>
--   </ul>
cellLayoutSetAttributes :: (MonadIO m, IsCellLayout self, IsCellRenderer cell, IsTreeModel (model row), IsTypedTreeModel model) => self -> cell -> model row -> (row -> [AttrOp cell 'AttrSet]) -> m ()

-- | Like <a>cellLayoutSetAttributes</a>, but allows any IO action to be
--   used
cellLayoutSetDataFunction :: (MonadIO m, IsCellLayout self, IsCellRenderer cell, IsTreeModel (model row), IsTypedTreeModel model) => self -> cell -> model row -> (row -> IO ()) -> m ()

-- | Install a function that looks up a row in the model and sets the
--   attributes of the <a>CellRenderer</a> <tt>cell</tt> using the row's
--   content.
cellLayoutSetDataFunc' :: (MonadIO m, IsCellLayout self, IsCellRenderer cell, IsTreeModel model) => self -> cell -> model -> (TreeIter -> IO ()) -> m ()
convertIterFromParentToChildModel :: TreeIter -> TreeModel -> TreeModel -> IO TreeIter


-- | A widget used to choose from a list of items.
--   
--   <ul>
--   <li>Module available since Gtk+ version 2.4</li>
--   </ul>
module Data.GI.Gtk.ComboBox

-- | Convenience function which constructs a new text combo box that is a
--   <a>ComboBox</a> just displaying strings. This function internally
--   calls <a>comboBoxSetModelText</a> after creating a new combo box.
comboBoxNewText :: MonadIO m => m ComboBox

-- | Create a combo box that holds strings.
--   
--   This function stores a <a>SeqStore</a> with the widget and sets the
--   model to the list store. The widget can contain only strings. The
--   model can be retrieved with <a>comboBoxGetModel</a>. The list store
--   can be retrieved with <a>comboBoxGetModelText</a>. Any exisiting model
--   or renderers are removed before setting the new text model. Note that
--   the functions <a>comboBoxAppendText</a>, <a>comboBoxInsertText</a>,
--   <a>comboBoxPrependText</a>, <a>comboBoxRemoveText</a> and
--   <a>comboBoxGetActiveText</a> can be called on a combo box only once
--   <a>comboBoxSetModelText</a> is called.
comboBoxSetModelText :: (MonadIO m, IsComboBox self) => self -> m (SeqStore Text)

-- | Retrieve the model that was created with <a>comboBoxSetModelText</a>.
comboBoxGetModelText :: (MonadIO m, IsComboBox self) => self -> m (SeqStore Text)

-- | Appends <tt>string</tt> to the list of strings stored in
--   <tt>comboBox</tt>. Note that you can only use this function with combo
--   boxes constructed with <a>comboBoxNewText</a>. Returns the index of
--   the appended text.
comboBoxAppendText :: (MonadIO m, IsComboBox self) => self -> Text -> m Int32

-- | Inserts <tt>string</tt> at <tt>position</tt> in the list of strings
--   stored in <tt>comboBox</tt>. Note that you can only use this function
--   with combo boxes constructed with <a>comboBoxNewText</a>.
comboBoxInsertText :: (MonadIO m, IsComboBox self) => self -> Int32 -> Text -> m ()

-- | Prepends <tt>string</tt> to the list of strings stored in
--   <tt>comboBox</tt>. Note that you can only use this function with combo
--   boxes constructed with <a>comboBoxNewText</a>.
comboBoxPrependText :: (Applicative m, MonadIO m, IsComboBox self) => self -> Text -> m ()

-- | Removes the string at <tt>position</tt> from <tt>comboBox</tt>. Note
--   that you can only use this function with combo boxes constructed with
--   <a>comboBoxNewText</a>.
comboBoxRemoveText :: (MonadIO m, IsComboBox self) => self -> Int32 -> m ()

-- | Returns the currently active string in <tt>comboBox</tt> or
--   <tt>Nothing</tt> if none is selected. Note that you can only use this
--   function with combo boxes constructed with <a>comboBoxNewText</a>.
comboBoxGetActiveText :: (MonadIO m, IsComboBox self) => self -> m (Maybe Text)


-- | Utility functions for threading
module Data.GI.Gtk.Threading

-- | Inform gi-gtk-hs what thread is running the gtk main loop.
setGUIThread :: Thread -> IO ()

-- | Get the Thread that is running the Gtk main loop, if it has been set.
getGUIThread :: IO (Maybe Thread)

-- | Inform gi-gtk-hs that the current thread is, or will be, running the
--   gtk main loop.
--   
--   Equivalent to <tt><a>threadSelf</a> &gt;&gt;= <a>setGUIThread</a></tt>
setCurrentThreadAsGUIThread :: IO ()

-- | Queue an action to be run in the GTK event loop. If called from the
--   same process as the event loop, this runs the action directly.
--   Otherwise, this queues it in GTK's event loop and blocks until the
--   action is complete
--   
--   You must call <a>setGUIThread</a> or
--   <a>setCurrentThreadAsGUIThread</a> before this.
--   
--   Priority is typically between <a>PRIORITY_HIGH_IDLE</a> (100) and
--   <a>PRIORITY_DEFAULT_IDLE</a> (200)
postGUISyncWithPriority :: Int32 -> IO a -> IO a

-- | Queue an action to be run in the GTK event loop. If called from the
--   same process as the event loop, this runs the action directly.
--   Otherwise, this queues it in GTK's event loop and blocks until the
--   action is complete
--   
--   You must call <a>setGUIThread</a> or
--   <a>setCurrentThreadAsGUIThread</a> before this.
--   
--   Equivalent to <tt><a>postGUISyncWithPriority</a>
--   <a>PRIORITY_DEFAULT_IDLE</a></tt>
postGUISync :: IO a -> IO a

-- | Queue an action to be run in the GTK event loop. This function queues
--   the event regardless of what process it is called from, and returns
--   immidietly.
--   
--   Priority is typically between <a>PRIORITY_HIGH_IDLE</a> (100) and
--   <a>PRIORITY_DEFAULT_IDLE</a> (200)
postGUIASyncWithPriority :: Int32 -> IO () -> IO ()

-- | Queue an action to be run in the GTK event loop. This function queues
--   the event regardless of what process it is called from, and returns
--   immidietly.
--   
--   Equivalent to <tt><a>postGUIASyncWithPriority</a>
--   <a>PRIORITY_DEFAULT_IDLE</a></tt>
postGUIASync :: IO () -> IO ()

-- | Test if two <a>Thread</a>s refer to the same OS thread. A
--   <a>Thread</a> can be gotten from <a>threadSelf</a>. Note that
--   <a>threadSelf</a> only makes sense from a bound thread.
compareThreads :: Thread -> Thread -> IO Bool

-- | Check if the current thread is the Gtk gui thread.
--   
--   You must call <a>setGUIThread</a> or
--   <a>setCurrentThreadAsGUIThread</a> before this. This only makes sense
--   when called from a bound thread.
isGUIThread :: IO Bool

-- | Memory-managed wrapper type.
newtype () => Thread
Thread :: ManagedPtr Thread -> Thread

-- | This function returns the <a>Thread</a> corresponding to the current
--   thread. Note that this function does not increase the reference count
--   of the returned struct.
--   
--   This function will return a <a>Thread</a> even for threads that were
--   not created by GLib (i.e. those created by other threading APIs). This
--   may be useful for thread identification purposes (i.e. comparisons)
--   but you must not use GLib functions (such as <a>threadJoin</a>) on
--   these threads.
threadSelf :: (HasCallStack, MonadIO m) => m Thread


-- | Helper functions for working with <a>Widget</a>s.
module Data.GI.Gtk.Widget

-- | Print out a tree of decendents for a given GTK <a>Widget</a>. This
--   function is mainly to help with debugging.
--   
--   This function outputs a tree of <a>Widget</a>s like the following:
--   
--   <pre>
--   GtkApplicationWindow  0x00000000068de2a0
--     GtkMenuBar  0x0000000006c661d0
--       GtkModelMenuItem  0x0000000006c72b00
--         GtkAccelLabel  0x0000000006c73b60
--       GtkModelMenuItem  0x0000000006c723c0
--         GtkAccelLabel  0x0000000006c733a0
--     GtkNotebook  0x0000000006b0a200
--       GtkPaned  0x0000000006b073c0
--         GtkScrolledWindow  0x0000000006b0c7c0
--           VteTerminal  0x00000000068af4a0
--         GtkScrolledWindow  0x0000000006b0c470
--           VteTerminal  0x00000000068af370
--   </pre>
--   
--   Note that you may also be interested in <a>GTKInspector</a>, which is
--   a built-in interactive debugger for GTK applications.
printWidgetTree :: forall m a. (MonadIO m, IsWidget a) => a -> m ()

module Data.GI.Gtk

-- | The type of license for an application.
--   
--   This enumeration can be expanded at later date.
--   
--   <i>Since: 3.0</i>
data () => License

-- | No license specified
LicenseUnknown :: License

-- | A license text is going to be specified by the developer
LicenseCustom :: License

-- | The GNU General Public License, version 2.0 or later
LicenseGpl20 :: License

-- | The GNU General Public License, version 3.0 or later
LicenseGpl30 :: License

-- | The GNU Lesser General Public License, version 2.1 or later
LicenseLgpl21 :: License

-- | The GNU Lesser General Public License, version 3.0 or later
LicenseLgpl30 :: License

-- | The BSD standard license
LicenseBsd :: License

-- | The MIT/X11 standard license
LicenseMitX11 :: License

-- | The Artistic License, version 2.0
LicenseArtistic :: License

-- | The GNU General Public License, version 2.0 only. Since 3.12.
LicenseGpl20Only :: License

-- | The GNU General Public License, version 3.0 only. Since 3.12.
LicenseGpl30Only :: License

-- | The GNU Lesser General Public License, version 2.1 only. Since 3.12.
LicenseLgpl21Only :: License

-- | The GNU Lesser General Public License, version 3.0 only. Since 3.12.
LicenseLgpl30Only :: License

-- | The GNU Affero General Public License, version 3.0 or later. Since:
--   3.22.
LicenseAgpl30 :: License

-- | The GNU Affero General Public License, version 3.0 only. Since:
--   3.22.27.
LicenseAgpl30Only :: License

-- | The 3-clause BSD licence. Since: 3.24.20.
LicenseBsd3 :: License

-- | The Apache License, version 2.0. Since: 3.24.20.
LicenseApache20 :: License

-- | The Mozilla Public License, version 2.0. Since: 3.24.20.
LicenseMpl20 :: License

-- | Catch-all for unknown values
AnotherLicense :: Int -> License

-- | Memory-managed wrapper type.
newtype () => Separator
Separator :: ManagedPtr Separator -> Separator

-- | Memory-managed wrapper type.
newtype () => Arrow
Arrow :: ManagedPtr Arrow -> Arrow

-- | Type class for types which can be safely cast to <a>Label</a>, for
--   instance with <a>toLabel</a>.
class (GObject o, IsDescendantOf Label o) => IsLabel o

-- | Memory-managed wrapper type.
newtype () => Fixed
Fixed :: ManagedPtr Fixed -> Fixed

-- | Memory-managed wrapper type.
newtype () => Bin
Bin :: ManagedPtr Bin -> Bin

-- | Memory-managed wrapper type.
newtype () => Builder
Builder :: ManagedPtr Builder -> Builder

-- | Memory-managed wrapper type.
newtype () => Table
Table :: ManagedPtr Table -> Table

-- | Haskell-side representation of a <tt>GValue</tt>.
newtype () => GValue
GValue :: ManagedPtr GValue -> GValue

-- | Memory-managed wrapper type.
newtype () => Window
Window :: ManagedPtr Window -> Window

-- | A <a>Window</a> can be one of these types. Most things you’d consider
--   a “window” should have type <tt><i>GTK_WINDOW_TOPLEVEL</i></tt>;
--   windows with this type are managed by the window manager and have a
--   frame by default (call <a>windowSetDecorated</a> to toggle the frame).
--   Windows with type <tt><i>GTK_WINDOW_POPUP</i></tt> are ignored by the
--   window manager; window manager keybindings won’t work on them, the
--   window manager won’t decorate the window with a frame, many GTK+
--   features that rely on the window manager will not work (e.g. resize
--   grips and maximization/minimization). <tt><i>GTK_WINDOW_POPUP</i></tt>
--   is used to implement widgets such as <a>Menu</a> or tooltips that you
--   normally don’t think of as windows per se. Nearly all windows should
--   be <tt><i>GTK_WINDOW_TOPLEVEL</i></tt>. In particular, do not use
--   <tt><i>GTK_WINDOW_POPUP</i></tt> just to turn off the window borders;
--   use <a>windowSetDecorated</a> for that.
data () => WindowType

-- | A regular window, such as a dialog.
WindowTypeToplevel :: WindowType

-- | A special window such as a tooltip.
WindowTypePopup :: WindowType

-- | Catch-all for unknown values
AnotherWindowType :: Int -> WindowType

-- | A GError, consisting of a domain, code and a human readable message.
--   These can be accessed by <a>gerrorDomain</a>, <a>gerrorCode</a> and
--   <a>gerrorMessage</a> below.
newtype () => GError
GError :: ManagedPtr GError -> GError

-- | Memory-managed wrapper type.
newtype () => Settings
Settings :: ManagedPtr Settings -> Settings

-- | Type class for types which can be safely cast to <a>Window</a>, for
--   instance with <a>toWindow</a>.
class (GObject o, IsDescendantOf Window o) => IsWindow o

-- | The basic type. This corresponds to a wrapped <tt>GClosure</tt> on the
--   C side, which is a boxed object.
data () => GClosure a

-- | A newtype for use on the Haskell side.
newtype () => GType
GType :: CGType -> GType
[gtypeToCGType] :: GType -> CGType

-- | A <a>GParamSpec</a>. See <a>Data.GI.Base.GParamSpec</a> for further
--   methods.
newtype () => GParamSpec
GParamSpec :: ManagedPtr GParamSpec -> GParamSpec

-- | A pointer to an equality checking function on the C side.
type GEqualFunc a = FunPtr PtrWrapped a -> PtrWrapped a -> IO Int32

-- | A pointer to a hashing function on the C side.
type GHashFunc a = FunPtr PtrWrapped a -> IO Word32

-- | Destroy the memory pointed to by a given pointer type.
type GDestroyNotify ptr = FunPtr ptr -> IO ()

-- | Some APIs, such as <a>GHashTable</a>, pass around scalar types wrapped
--   into a pointer. We encode such a type as follows.
newtype () => PtrWrapped a
PtrWrapped :: Ptr a -> PtrWrapped a
[unwrapPtr] :: PtrWrapped a -> Ptr a

-- | A <a>GSList</a>, mapped to a list on the Haskell side. Marshalling is
--   done in <a>Data.GI.Base.BasicConversions</a>.
data () => GSList a
GSList :: Ptr (GSList a) -> GSList a

-- | A <a>GList</a>, mapped to a list on the Haskell side. Marshalling is
--   done in <a>Data.GI.Base.BasicConversions</a>.
data () => GList a
GList :: Ptr (GList a) -> GList a

-- | A <a>GHashTable</a>. It is mapped to a <a>Map</a> on the Haskell side.
data () => GHashTable a b
GHashTable :: Ptr (GHashTable a b) -> GHashTable a b

-- | A <a>GByteArray</a>. Marshalling for this type is done in
--   <a>Data.GI.Base.BasicConversions</a>, it is packed to a
--   <a>ByteString</a> on the Haskell side.
data () => GByteArray
GByteArray :: Ptr GByteArray -> GByteArray

-- | A <a>GPtrArray</a>. Marshalling for this type is done in
--   <a>Data.GI.Base.BasicConversions</a>, it is mapped to a list on the
--   Haskell side.
data () => GPtrArray a
GPtrArray :: Ptr (GPtrArray a) -> GPtrArray a

-- | A <a>GArray</a>. Marshalling for this type is done in
--   <a>Data.GI.Base.BasicConversions</a>, it is mapped to a list on the
--   Haskell side.
data () => GArray a
GArray :: Ptr (GArray a) -> GArray a

-- | An enum usable as a flag for a function.
class Enum a => IsGFlag a

-- | A <a>GVariant</a>. See <a>Data.GI.Base.GVariant</a> for further
--   methods.
newtype () => GVariant
GVariant :: ManagedPtr GVariant -> GVariant

-- | A common omission in the introspection data is missing (nullable)
--   annotations for return types, when they clearly are nullable. (A
--   common idiom is "Returns: valid value, or %NULL if something went
--   wrong.")
--   
--   Haskell wrappers will raise this exception if the return value is an
--   unexpected <a>nullPtr</a>.
data () => UnexpectedNullPointerReturn
UnexpectedNullPointerReturn :: Text -> UnexpectedNullPointerReturn
[nullPtrErrorMsg] :: UnexpectedNullPointerReturn -> Text

-- | A type identifier in the GLib type system. This is the low-level type
--   associated with the representation in memory, when using this on the
--   Haskell side use <a>GType</a> below.
type CGType = Word64

-- | Flags with an associated <a>GType</a>.
class TypedObject a => BoxedFlags a

-- | Enums with an associated <a>GType</a>.
class TypedObject a => BoxedEnum a

-- | A wrapped <a>GObject</a>, or any other type that descends from it.
class (ManagedPtrNewtype a, TypedObject a) => GObject a

-- | Chunks of memory whose allocation/deallocation info has been
--   registered with the GLib type system.
class (ManagedPtrNewtype a, TypedObject a) => GBoxed a

-- | A wrapped object that has an associated GLib type. This does not
--   necessarily descend from <a>GObject</a>, that constraint is
--   implemented by <a>GObject</a> below.
class HasParentTypes a => TypedObject a

-- | The <a>GType</a> for this object.
glibType :: TypedObject a => IO GType

-- | A ptr to a memory block which we know how to allocate and fill with
--   zero.
class BoxedPtr a => CallocPtr a

-- | Allocate a zero-initialized block of memory for the given type.
boxedPtrCalloc :: CallocPtr a => IO (Ptr a)

-- | Pointers to chunks of memory which we know how to copy and release.
class ManagedPtrNewtype a => BoxedPtr a

-- | Make a copy of the given <a>BoxedPtr</a>.
boxedPtrCopy :: BoxedPtr a => a -> IO a

-- | A pointer to a function for freeing the given pointer.
boxedPtrFree :: BoxedPtr a => a -> IO ()

-- | A constraint ensuring that the given type is a newtype over a
--   <a>ManagedPtr</a>.
class Coercible a ManagedPtr () => ManagedPtrNewtype a
toManagedPtr :: ManagedPtrNewtype a => a -> ManagedPtr a

-- | Thin wrapper over <a>ForeignPtr</a>, supporting the extra notion of
--   <tt>disowning</tt>, that is, not running the finalizers associated
--   with the foreign ptr.
data () => ManagedPtr a
ManagedPtr :: ForeignPtr a -> Maybe CallStack -> IORef (Maybe CallStack) -> ManagedPtr a
[managedForeignPtr] :: ManagedPtr a -> ForeignPtr a

-- | <a>CallStack</a> for the call that created the pointer.
[managedPtrAllocCallStack] :: ManagedPtr a -> Maybe CallStack

-- | When disowned, the <a>CallStack</a> for the disowning call.
[managedPtrIsDisowned] :: ManagedPtr a -> IORef (Maybe CallStack)

-- | A DictEntry <a>GVariant</a> is isomorphic to a two-tuple. Wrapping the
--   values into a <tt>GVariantDictentry</tt> allows the <a>IsGVariant</a>
--   instance to do the right thing.
data () => GVariantDictEntry key value
GVariantDictEntry :: key -> value -> GVariantDictEntry key value

-- | An object representing a DBus signature, which is a particular type of
--   <a>GVariant</a> too. (Just a string with some specific requirements.)
--   In order to construct/deconstruct a <a>GVariantSignature</a> one can
--   use <a>newGVariantSignature</a> and <a>gvariantSignatureToText</a>.
data () => GVariantSignature

-- | An object representing a DBus object path, which is a particular type
--   of <a>GVariant</a> too. (Just a string with some specific
--   requirements.) In order to construct/deconstruct a
--   <a>GVariantObjectPath</a> one can use <a>newGVariantObjectPath</a> and
--   <a>gvariantObjectPathToText</a>.
data () => GVariantObjectPath
newtype () => GVariantHandle
GVariantHandle :: Int32 -> GVariantHandle

-- | Haskell has no notion of one element tuples, but GVariants do, so the
--   following allows for marshalling one element tuples properly using
--   <a>fromGVariant</a> and <a>toGVariant</a>. For instance, to construct
--   a single element tuple containing a string, you could do
--   
--   <pre>
--   toGVariant (GVariantSinglet "Test")
--   </pre>
newtype () => GVariantSinglet a
GVariantSinglet :: a -> GVariantSinglet a

-- | The typeclass for basic type <a>GVariant</a> types, i.e. those that
--   are not containers.
class Ord a => IsGVariantBasicType a

-- | The typeclass for types that can be automatically marshalled into
--   <a>GVariant</a> using <a>toGVariant</a> and <a>fromGVariant</a>.
class () => IsGVariant a

-- | Convert a value of the given type into a GVariant.
toGVariant :: IsGVariant a => a -> IO GVariant

-- | Try to decode a <a>GVariant</a> into a target type. If the conversion
--   fails we return <a>Nothing</a>. The type that was expected can be
--   obtained by calling <a>toGVariantFormatString</a>, and the actual type
--   as understood by the <a>GVariant</a> code can be obtained by calling
--   <tt>gvariantToTypeString</tt>.
fromGVariant :: IsGVariant a => GVariant -> IO (Maybe a)

-- | The expected format string for this type (the argument is ignored).
toGVariantFormatString :: IsGVariant a => a -> Text

-- | Class for types that can be marshaled back and forth between Haskell
--   values and <a>GValue</a>s. These are low-level methods, you might want
--   to use <a>toGValue</a> and <a>fromGValue</a> instead for a higher
--   level interface.
class () => IsGValue a
gvalueGType_ :: IsGValue a => IO GType
gvalueSet_ :: IsGValue a => Ptr GValue -> a -> IO ()
gvalueGet_ :: IsGValue a => Ptr GValue -> IO a

-- | Support for overloaded signal connectors.
data () => SignalProxy object info

-- | A signal connector annotated with a detail.
[:::] :: forall object info. SignalProxy object info -> Text -> SignalProxy object info

-- | A signal connector for the <tt>notify</tt> signal on the given
--   property.
[PropertyNotify] :: forall info1 (propName :: Symbol) object (pl :: Symbol). (info1 ~ ResolveAttribute propName object, AttrInfo info1, pl ~ AttrLabel info1, KnownSymbol pl) => AttrLabelProxy propName -> SignalProxy object GObjectNotifySignalInfo

-- | Constructors for the different operations allowed on an attribute.
data () => AttrOp obj (tag :: AttrOpTag)

-- | Assign a value to an attribute
[:=] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrSetTypeConstraint info b) => AttrLabelProxy attr -> b -> AttrOp obj tag

-- | Assign the result of an IO action to an attribute
[:=>] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrSetTypeConstraint info b) => AttrLabelProxy attr -> IO b -> AttrOp obj tag

-- | Apply an update function to an attribute
[:~] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b a. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, tag ~ 'AttrSet, AttrOpAllowed 'AttrSet info obj, AttrOpAllowed 'AttrGet info obj, AttrSetTypeConstraint info b, a ~ AttrGetType info) => AttrLabelProxy attr -> (a -> b) -> AttrOp obj tag

-- | Apply an IO update function to an attribute
[:~>] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b a. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, tag ~ 'AttrSet, AttrOpAllowed 'AttrSet info obj, AttrOpAllowed 'AttrGet info obj, AttrSetTypeConstraint info b, a ~ AttrGetType info) => AttrLabelProxy attr -> (a -> IO b) -> AttrOp obj tag

-- | Assign a value to an attribute, allocating any necessary memory for
--   representing the Haskell value as a C value. Note that it is the
--   responsibility of the caller to make sure that the memory is freed
--   when no longer used, otherwise there will be a memory leak. In the
--   majority of cases you probably want to use <a>:=</a> instead, which
--   has no potential memory leaks (at the cost of sometimes requiring some
--   explicit Haskell -&gt; C marshalling).
[:&=] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrTransferTypeConstraint info b, AttrSetTypeConstraint info (AttrTransferType info)) => AttrLabelProxy attr -> b -> AttrOp obj tag

-- | Connect the given signal to a signal handler.
[On] :: forall obj info (tag :: AttrOpTag). (GObject obj, SignalInfo info) => SignalProxy obj info -> ((?self :: obj) => HaskellCallbackType info) -> AttrOp obj tag

-- | Like <a>On</a>, but connect after the default signal.
[After] :: forall obj info (tag :: AttrOpTag). (GObject obj, SignalInfo info) => SignalProxy obj info -> ((?self :: obj) => HaskellCallbackType info) -> AttrOp obj tag
infixr 0 :=
infixr 0 :=>
infixr 0 :~
infixr 0 :~>

-- | Each error domain's error enumeration type should be an instance of
--   this class. This class helps to hide the raw error and domain codes
--   from the user.
--   
--   Example for <a>PixbufError</a>:
--   
--   <pre>
--   instance GErrorClass PixbufError where
--     gerrorClassDomain _ = "gdk-pixbuf-error-quark"
--   </pre>
class Enum err => GErrorClass err
gerrorClassDomain :: GErrorClass err => err -> Text

-- | A human readable error message.
type GErrorMessage = Text

-- | A code to identify a specific error within a given
--   <a>GErrorDomain</a>. Most of time you will not need to deal with this
--   raw code since there is an enumeration type for each error domain. Of
--   course which enumeration to use depends on the error domain, but if
--   you use <a>catchGErrorJustDomain</a> or <a>handleGErrorJustDomain</a>,
--   this is worked out for you automatically.
type GErrorCode = C_gint

-- | A code used to identify the "namespace" of the error. Within each
--   error domain all the error codes are defined in an enumeration. Each
--   gtk/gnome module that uses GErrors has its own error domain. The
--   rationale behind using error domains is so that each module can
--   organise its own error codes without having to coordinate on a global
--   error code list.
type GErrorDomain = GQuark

-- | The function used to translate messages in e.g. <a>IconFactory</a> and
--   <a>ActionGroup</a>.
type TranslateFunc = Text -> IO Text

-- | The function used to translate messages in e.g. <a>IconFactory</a> and
--   <a>ActionGroup</a>.
type TranslateFunc_WithClosures = Text -> Ptr () -> IO Text

-- | Type for the callback on the (unwrapped) C side.
type C_TranslateFunc = CString -> Ptr () -> IO CString

-- | The type of the callback functions used for e.g. iterating over the
--   children of a container, see <a>containerForeach</a>.
type Callback = Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_Callback = Ptr Widget -> Ptr () -> IO ()

-- | Memory-managed wrapper type.
newtype () => LevelBar
LevelBar :: ManagedPtr LevelBar -> LevelBar

-- | Memory-managed wrapper type.
newtype () => Frame
Frame :: ManagedPtr Frame -> Frame

-- | Memory-managed wrapper type.
newtype () => Paned
Paned :: ManagedPtr Paned -> Paned

-- | Memory-managed wrapper type.
newtype () => Scale
Scale :: ManagedPtr Scale -> Scale

-- | Describes how the border of a UI element should be rendered.
data () => BorderStyle

-- | No visible border
BorderStyleNone :: BorderStyle

-- | A single line segment
BorderStyleSolid :: BorderStyle

-- | Looks as if the content is sunken into the canvas
BorderStyleInset :: BorderStyle

-- | Looks as if the content is coming out of the canvas
BorderStyleOutset :: BorderStyle

-- | Same as <i><tt>gTKBORDERSTYLENONE</tt></i>
BorderStyleHidden :: BorderStyle

-- | A series of round dots
BorderStyleDotted :: BorderStyle

-- | A series of square-ended dashes
BorderStyleDashed :: BorderStyle

-- | Two parallel lines with some space between them
BorderStyleDouble :: BorderStyle

-- | Looks as if it were carved in the canvas
BorderStyleGroove :: BorderStyle

-- | Looks as if it were coming out of the canvas
BorderStyleRidge :: BorderStyle

-- | Catch-all for unknown values
AnotherBorderStyle :: Int -> BorderStyle

-- | Memory-managed wrapper type.
newtype () => Border
Border :: ManagedPtr Border -> Border

-- | Memory-managed wrapper type.
newtype () => Widget
Widget :: ManagedPtr Widget -> Widget

-- | Memory-managed wrapper type.
newtype () => StyleProvider
StyleProvider :: ManagedPtr StyleProvider -> StyleProvider

-- | Memory-managed wrapper type.
newtype () => TreeSortable
TreeSortable :: ManagedPtr TreeSortable -> TreeSortable

-- | Memory-managed wrapper type.
newtype () => Box
Box :: ManagedPtr Box -> Box

-- | Memory-managed wrapper type.
newtype () => Assistant
Assistant :: ManagedPtr Assistant -> Assistant

-- | Memory-managed wrapper type.
newtype () => ButtonBox
ButtonBox :: ManagedPtr ButtonBox -> ButtonBox

-- | Memory-managed wrapper type.
newtype () => ModelButton
ModelButton :: ManagedPtr ModelButton -> ModelButton

-- | Memory-managed wrapper type.
newtype () => ScrolledWindow
ScrolledWindow :: ManagedPtr ScrolledWindow -> ScrolledWindow

-- | Memory-managed wrapper type.
newtype () => Gesture
Gesture :: ManagedPtr Gesture -> Gesture

-- | Memory-managed wrapper type.
newtype () => TreeView
TreeView :: ManagedPtr TreeView -> TreeView

-- | Memory-managed wrapper type.
newtype () => FileChooser
FileChooser :: ManagedPtr FileChooser -> FileChooser

-- | Memory-managed wrapper type.
newtype () => Image
Image :: ManagedPtr Image -> Image

-- | Memory-managed wrapper type.
newtype () => Label
Label :: ManagedPtr Label -> Label

-- | Memory-managed wrapper type.
newtype () => Alignment
Alignment :: ManagedPtr Alignment -> Alignment

-- | Memory-managed wrapper type.
newtype () => Toolbar
Toolbar :: ManagedPtr Toolbar -> Toolbar

-- | Memory-managed wrapper type.
newtype () => GesturePan
GesturePan :: ManagedPtr GesturePan -> GesturePan

-- | Memory-managed wrapper type.
newtype () => VBox
VBox :: ManagedPtr VBox -> VBox

-- | Memory-managed wrapper type.
newtype () => HBox
HBox :: ManagedPtr HBox -> HBox

-- | Memory-managed wrapper type.
newtype () => Notebook
Notebook :: ManagedPtr Notebook -> Notebook

-- | Memory-managed wrapper type.
newtype () => HandleBox
HandleBox :: ManagedPtr HandleBox -> HandleBox

-- | Memory-managed wrapper type.
newtype () => EventController
EventController :: ManagedPtr EventController -> EventController

-- | Memory-managed wrapper type.
newtype () => RecentChooser
RecentChooser :: ManagedPtr RecentChooser -> RecentChooser

-- | Memory-managed wrapper type.
newtype () => RecentManager
RecentManager :: ManagedPtr RecentManager -> RecentManager

-- | Memory-managed wrapper type.
newtype () => Button
Button :: ManagedPtr Button -> Button

-- | Memory-managed wrapper type.
newtype () => Revealer
Revealer :: ManagedPtr Revealer -> Revealer

-- | Memory-managed wrapper type.
newtype () => Stack
Stack :: ManagedPtr Stack -> Stack

-- | Memory-managed wrapper type.
newtype () => Style
Style :: ManagedPtr Style -> Style

-- | Memory-managed wrapper type.
newtype () => TextView
TextView :: ManagedPtr TextView -> TextView

-- | Memory-managed wrapper type.
newtype () => Menu
Menu :: ManagedPtr Menu -> Menu

-- | Memory-managed wrapper type.
newtype () => IconSet
IconSet :: ManagedPtr IconSet -> IconSet

-- | Memory-managed wrapper type.
newtype () => SpinButton
SpinButton :: ManagedPtr SpinButton -> SpinButton

-- | Memory-managed wrapper type.
newtype () => Calendar
Calendar :: ManagedPtr Calendar -> Calendar

-- | Memory-managed wrapper type.
newtype () => EventControllerScroll
EventControllerScroll :: ManagedPtr EventControllerScroll -> EventControllerScroll

-- | Memory-managed wrapper type.
newtype () => FileFilterInfo
FileFilterInfo :: ManagedPtr FileFilterInfo -> FileFilterInfo

-- | Describes primary purpose of the input widget. This information is
--   useful for on-screen keyboards and similar input methods to decide
--   which keys should be presented to the user.
--   
--   Note that the purpose is not meant to impose a totally strict rule
--   about allowed characters, and does not replace input validation. It is
--   fine for an on-screen keyboard to let the user override the character
--   set restriction that is expressed by the purpose. The application is
--   expected to validate the entry contents, even if it specified a
--   purpose.
--   
--   The difference between <i><tt>gTKINPUTPURPOSEDIGITS</tt></i> and
--   <i><tt>gTKINPUTPURPOSENUMBER</tt></i> is that the former accepts only
--   digits while the latter also some punctuation (like commas or points,
--   plus, minus) and “e” or “E” as in 3.14E+000.
--   
--   This enumeration may be extended in the future; input methods should
--   interpret unknown values as “free form”.
--   
--   <i>Since: 3.6</i>
data () => InputPurpose

-- | Allow any character
InputPurposeFreeForm :: InputPurpose

-- | Allow only alphabetic characters
InputPurposeAlpha :: InputPurpose

-- | Allow only digits
InputPurposeDigits :: InputPurpose

-- | Edited field expects numbers
InputPurposeNumber :: InputPurpose

-- | Edited field expects phone number
InputPurposePhone :: InputPurpose

-- | Edited field expects URL
InputPurposeUrl :: InputPurpose

-- | Edited field expects email address
InputPurposeEmail :: InputPurpose

-- | Edited field expects the name of a person
InputPurposeName :: InputPurpose

-- | Like <i><tt>gTKINPUTPURPOSEFREEFORM</tt></i>, but characters are
--   hidden
InputPurposePassword :: InputPurpose

-- | Like <i><tt>gTKINPUTPURPOSEDIGITS</tt></i>, but characters are hidden
InputPurposePin :: InputPurpose

-- | Allow any character, in addition to control codes
InputPurposeTerminal :: InputPurpose

-- | Catch-all for unknown values
AnotherInputPurpose :: Int -> InputPurpose

-- | Memory-managed wrapper type.
newtype () => RecentFilterInfo
RecentFilterInfo :: ManagedPtr RecentFilterInfo -> RecentFilterInfo

-- | Memory-managed wrapper type.
newtype () => TargetEntry
TargetEntry :: ManagedPtr TargetEntry -> TargetEntry

-- | Memory-managed wrapper type.
newtype () => TreeModel
TreeModel :: ManagedPtr TreeModel -> TreeModel

-- | Memory-managed wrapper type.
newtype () => PlacesSidebar
PlacesSidebar :: ManagedPtr PlacesSidebar -> PlacesSidebar

-- | Memory-managed wrapper type.
newtype () => ColorChooserWidget
ColorChooserWidget :: ManagedPtr ColorChooserWidget -> ColorChooserWidget

-- | Memory-managed wrapper type.
newtype () => Scrollbar
Scrollbar :: ManagedPtr Scrollbar -> Scrollbar

-- | Memory-managed wrapper type.
newtype () => BindingSet
BindingSet :: ManagedPtr BindingSet -> BindingSet

-- | Memory-managed wrapper type.
newtype () => BindingArg
BindingArg :: ManagedPtr BindingArg -> BindingArg

-- | Memory-managed wrapper type.
newtype () => Adjustment
Adjustment :: ManagedPtr Adjustment -> Adjustment

-- | Defines the policy to be used in a scrollable widget when updating the
--   scrolled window adjustments in a given orientation.
data () => ScrollablePolicy

-- | Scrollable adjustments are based on the minimum size
ScrollablePolicyMinimum :: ScrollablePolicy

-- | Scrollable adjustments are based on the natural size
ScrollablePolicyNatural :: ScrollablePolicy

-- | Catch-all for unknown values
AnotherScrollablePolicy :: Int -> ScrollablePolicy

-- | Reading directions for text.
data () => TextDirection

-- | No direction.
TextDirectionNone :: TextDirection

-- | Left to right text direction.
TextDirectionLtr :: TextDirection

-- | Right to left text direction.
TextDirectionRtl :: TextDirection

-- | Catch-all for unknown values
AnotherTextDirection :: Int -> TextDirection

-- | This type indicates the current state of a widget; the state
--   determines how the widget is drawn. The <a>StateType</a> enumeration
--   is also used to identify different colors in a <a>Style</a> for
--   drawing, so states can be used for subparts of a widget as well as
--   entire widgets.
data () => StateType

-- | State during normal operation.
StateTypeNormal :: StateType

-- | State of a currently active widget, such as a depressed button.
StateTypeActive :: StateType

-- | State indicating that the mouse pointer is over the widget and the
--   widget will respond to mouse clicks.
StateTypePrelight :: StateType

-- | State of a selected item, such the selected row in a list.
StateTypeSelected :: StateType

-- | State indicating that the widget is unresponsive to user actions.
StateTypeInsensitive :: StateType

-- | The widget is inconsistent, such as checkbuttons or radiobuttons that
--   aren’t either set to <a>True</a> nor <a>False</a>, or buttons
--   requiring the user attention.
StateTypeInconsistent :: StateType

-- | The widget has the keyboard focus.
StateTypeFocused :: StateType

-- | Catch-all for unknown values
AnotherStateType :: Int -> StateType

-- | Built-in stock icon sizes.
data () => IconSize

-- | Invalid size.
IconSizeInvalid :: IconSize

-- | Size appropriate for menus (16px).
IconSizeMenu :: IconSize

-- | Size appropriate for small toolbars (16px).
IconSizeSmallToolbar :: IconSize

-- | Size appropriate for large toolbars (24px)
IconSizeLargeToolbar :: IconSize

-- | Size appropriate for buttons (16px)
IconSizeButton :: IconSize

-- | Size appropriate for drag and drop (32px)
IconSizeDnd :: IconSize

-- | Size appropriate for dialogs (48px)
IconSizeDialog :: IconSize

-- | Catch-all for unknown values
AnotherIconSize :: Int -> IconSize

-- | Memory-managed wrapper type.
newtype () => Layout
Layout :: ManagedPtr Layout -> Layout

-- | Memory-managed wrapper type.
newtype () => PageSetup
PageSetup :: ManagedPtr PageSetup -> PageSetup

-- | See also <a>printSettingsSetOrientation</a>.
data () => PageOrientation

-- | Portrait mode.
PageOrientationPortrait :: PageOrientation

-- | Landscape mode.
PageOrientationLandscape :: PageOrientation

-- | Reverse portrait mode.
PageOrientationReversePortrait :: PageOrientation

-- | Reverse landscape mode.
PageOrientationReverseLandscape :: PageOrientation

-- | Catch-all for unknown values
AnotherPageOrientation :: Int -> PageOrientation

-- | Memory-managed wrapper type.
newtype () => PaperSize
PaperSize :: ManagedPtr PaperSize -> PaperSize

-- | Memory-managed wrapper type.
newtype () => PrintContext
PrintContext :: ManagedPtr PrintContext -> PrintContext

-- | <i>No description available in the introspection data.</i>
type RcPropertyParser = GParamSpec -> String -> GValue -> IO Bool

-- | Memory-managed wrapper type.
newtype () => Requisition
Requisition :: ManagedPtr Requisition -> Requisition

-- | Memory-managed wrapper type.
newtype () => RecentData
RecentData :: ManagedPtr RecentData -> RecentData

-- | Memory-managed wrapper type.
newtype () => RecentInfo
RecentInfo :: ManagedPtr RecentInfo -> RecentInfo

-- | The <a>TargetFlags</a> enumeration is used to specify constraints on a
--   <a>TargetEntry</a>.
data () => TargetFlags

-- | If this is set, the target will only be selected for drags within a
--   single application.
TargetFlagsSameApp :: TargetFlags

-- | If this is set, the target will only be selected for drags within a
--   single widget.
TargetFlagsSameWidget :: TargetFlags

-- | If this is set, the target will not be selected for drags within a
--   single application.
TargetFlagsOtherApp :: TargetFlags

-- | If this is set, the target will not be selected for drags withing a
--   single widget.
TargetFlagsOtherWidget :: TargetFlags

-- | Catch-all for unknown values
AnotherTargetFlags :: Int -> TargetFlags

-- | Memory-managed wrapper type.
newtype () => CellArea
CellArea :: ManagedPtr CellArea -> CellArea

-- | Memory-managed wrapper type.
newtype () => FontChooser
FontChooser :: ManagedPtr FontChooser -> FontChooser

-- | Memory-managed wrapper type.
newtype () => IconFactory
IconFactory :: ManagedPtr IconFactory -> IconFactory

-- | Memory-managed wrapper type.
newtype () => ActionGroup
ActionGroup :: ManagedPtr ActionGroup -> ActionGroup

-- | Memory-managed wrapper type.
newtype () => Actionable
Actionable :: ManagedPtr Actionable -> Actionable

-- | Memory-managed wrapper type.
newtype () => CellLayout
CellLayout :: ManagedPtr CellLayout -> CellLayout

-- | Memory-managed wrapper type.
newtype () => TreeIter
TreeIter :: ManagedPtr TreeIter -> TreeIter

-- | Memory-managed wrapper type.
newtype () => Clipboard
Clipboard :: ManagedPtr Clipboard -> Clipboard

-- | Memory-managed wrapper type.
newtype () => SelectionData
SelectionData :: ManagedPtr SelectionData -> SelectionData

-- | Memory-managed wrapper type.
newtype () => Container
Container :: ManagedPtr Container -> Container

-- | Memory-managed wrapper type.
newtype () => WidgetPath
WidgetPath :: ManagedPtr WidgetPath -> WidgetPath

-- | Memory-managed wrapper type.
newtype () => EntryCompletion
EntryCompletion :: ManagedPtr EntryCompletion -> EntryCompletion

-- | Memory-managed wrapper type.
newtype () => FlowBoxChild
FlowBoxChild :: ManagedPtr FlowBoxChild -> FlowBoxChild

-- | Memory-managed wrapper type.
newtype () => FlowBox
FlowBox :: ManagedPtr FlowBox -> FlowBox

-- | Memory-managed wrapper type.
newtype () => IconView
IconView :: ManagedPtr IconView -> IconView

-- | Memory-managed wrapper type.
newtype () => TreePath
TreePath :: ManagedPtr TreePath -> TreePath

-- | Memory-managed wrapper type.
newtype () => ListBox
ListBox :: ManagedPtr ListBox -> ListBox

-- | Memory-managed wrapper type.
newtype () => ListBoxRow
ListBoxRow :: ManagedPtr ListBoxRow -> ListBoxRow

-- | Memory-managed wrapper type.
newtype () => TextBuffer
TextBuffer :: ManagedPtr TextBuffer -> TextBuffer

-- | Memory-managed wrapper type.
newtype () => TextTag
TextTag :: ManagedPtr TextTag -> TextTag

-- | Memory-managed wrapper type.
newtype () => ActionEntry
ActionEntry :: ManagedPtr ActionEntry -> ActionEntry

-- | Memory-managed wrapper type.
newtype () => TreeViewColumn
TreeViewColumn :: ManagedPtr TreeViewColumn -> TreeViewColumn

-- | Memory-managed wrapper type.
newtype () => CellRenderer
CellRenderer :: ManagedPtr CellRenderer -> CellRenderer

-- | Memory-managed wrapper type.
newtype () => TreeModelFilter
TreeModelFilter :: ManagedPtr TreeModelFilter -> TreeModelFilter

-- | Memory-managed wrapper type.
newtype () => TreeSelection
TreeSelection :: ManagedPtr TreeSelection -> TreeSelection

-- | Specifies a preference for height-for-width or width-for-height
--   geometry management.
data () => SizeRequestMode

-- | Prefer height-for-width geometry management
SizeRequestModeHeightForWidth :: SizeRequestMode

-- | Prefer width-for-height geometry management
SizeRequestModeWidthForHeight :: SizeRequestMode

-- | Don’t trade height-for-width or width-for-height
SizeRequestModeConstantSize :: SizeRequestMode

-- | Catch-all for unknown values
AnotherSizeRequestMode :: Int -> SizeRequestMode

-- | This is the signature of a function used to connect signals. It is
--   used by the <a>builderConnectSignals</a> and
--   <a>builderConnectSignalsFull</a> methods. It is mainly intended for
--   interpreted language bindings, but could be useful where the
--   programmer wants more control over the signal connection process. Note
--   that this function can only be called once, subsequent calls will do
--   nothing.
--   
--   <i>Since: 2.12</i>
type BuilderConnectFunc = Builder -> Object -> Text -> Text -> Maybe Object -> [ConnectFlags] -> IO ()

-- | Memory-managed wrapper type.
newtype () => TextMark
TextMark :: ManagedPtr TextMark -> TextMark

-- | Memory-managed wrapper type.
newtype () => StyleProperties
StyleProperties :: ManagedPtr StyleProperties -> StyleProperties

-- | Memory-managed wrapper type.
newtype () => IconSource
IconSource :: ManagedPtr IconSource -> IconSource

-- | Memory-managed wrapper type.
newtype () => StyleContext
StyleContext :: ManagedPtr StyleContext -> StyleContext

-- | Memory-managed wrapper type.
newtype () => Application
Application :: ManagedPtr Application -> Application

-- | Memory-managed wrapper type.
newtype () => Plug
Plug :: ManagedPtr Plug -> Plug

-- | Memory-managed wrapper type.
newtype () => ComboBox
ComboBox :: ManagedPtr ComboBox -> ComboBox

-- | Memory-managed wrapper type.
newtype () => Entry
Entry :: ManagedPtr Entry -> Entry

-- | Memory-managed wrapper type.
newtype () => IconTheme
IconTheme :: ManagedPtr IconTheme -> IconTheme

-- | Memory-managed wrapper type.
newtype () => HeaderBar
HeaderBar :: ManagedPtr HeaderBar -> HeaderBar

-- | Memory-managed wrapper type.
newtype () => AccelGroup
AccelGroup :: ManagedPtr AccelGroup -> AccelGroup

-- | Memory-managed wrapper type.
newtype () => WindowGroup
WindowGroup :: ManagedPtr WindowGroup -> WindowGroup

-- | Memory-managed wrapper type.
newtype () => ContainerClass
ContainerClass :: ManagedPtr ContainerClass -> ContainerClass

-- | Memory-managed wrapper type.
newtype () => RcStyle
RcStyle :: ManagedPtr RcStyle -> RcStyle

-- | Describes a widget state. Widget states are used to match the widget
--   against CSS pseudo-classes. Note that GTK extends the regular CSS
--   classes and sometimes uses different names.
data () => StateFlags

-- | State during normal operation.
StateFlagsNormal :: StateFlags

-- | Widget is active.
StateFlagsActive :: StateFlags

-- | Widget has a mouse pointer over it.
StateFlagsPrelight :: StateFlags

-- | Widget is selected.
StateFlagsSelected :: StateFlags

-- | Widget is insensitive.
StateFlagsInsensitive :: StateFlags

-- | Widget is inconsistent.
StateFlagsInconsistent :: StateFlags

-- | Widget has the keyboard focus.
StateFlagsFocused :: StateFlags

-- | Widget is in a background toplevel window.
StateFlagsBackdrop :: StateFlags

-- | Widget is in left-to-right text direction. Since 3.8
StateFlagsDirLtr :: StateFlags

-- | Widget is in right-to-left text direction. Since 3.8
StateFlagsDirRtl :: StateFlags

-- | Widget is a link. Since 3.12
StateFlagsLink :: StateFlags

-- | The location the widget points to has already been visited. Since 3.12
StateFlagsVisited :: StateFlags

-- | Widget is checked. Since 3.14
StateFlagsChecked :: StateFlags

-- | Widget is highlighted as a drop target for DND. Since 3.20
StateFlagsDropActive :: StateFlags

-- | Catch-all for unknown values
AnotherStateFlags :: Int -> StateFlags

-- | Memory-managed wrapper type.
newtype () => Socket
Socket :: ManagedPtr Socket -> Socket

-- | Memory-managed wrapper type.
newtype () => Invisible
Invisible :: ManagedPtr Invisible -> Invisible

-- | Focus movement types.
data () => DirectionType

-- | Move forward.
DirectionTypeTabForward :: DirectionType

-- | Move backward.
DirectionTypeTabBackward :: DirectionType

-- | Move up.
DirectionTypeUp :: DirectionType

-- | Move down.
DirectionTypeDown :: DirectionType

-- | Move left.
DirectionTypeLeft :: DirectionType

-- | Move right.
DirectionTypeRight :: DirectionType

-- | Catch-all for unknown values
AnotherDirectionType :: Int -> DirectionType

-- | Memory-managed wrapper type.
newtype () => CssProvider
CssProvider :: ManagedPtr CssProvider -> CssProvider

-- | Memory-managed wrapper type.
newtype () => DrawingArea
DrawingArea :: ManagedPtr DrawingArea -> DrawingArea

-- | Memory-managed wrapper type.
newtype () => UIManager
UIManager :: ManagedPtr UIManager -> UIManager

-- | Memory-managed wrapper type.
newtype () => EventBox
EventBox :: ManagedPtr EventBox -> EventBox

-- | Memory-managed wrapper type.
newtype () => Tooltip
Tooltip :: ManagedPtr Tooltip -> Tooltip

-- | Memory-managed wrapper type.
newtype () => TargetList
TargetList :: ManagedPtr TargetList -> TargetList

-- | Memory-managed wrapper type.
newtype () => ScaleButton
ScaleButton :: ManagedPtr ScaleButton -> ScaleButton

-- | Memory-managed wrapper type.
newtype () => CellRendererText
CellRendererText :: ManagedPtr CellRendererText -> CellRendererText

-- | A function to set the properties of a cell instead of just using the
--   straight mapping between the cell and the model. This is useful for
--   customizing the cell renderer. For example, a function might get an
--   integer from the <i><tt>treeModel</tt></i>, and render it to the
--   “text” attribute of “cell” by converting it to its written equivalent.
--   This is set by calling <a>treeViewColumnSetCellDataFunc</a>
type TreeCellDataFunc = TreeViewColumn -> CellRenderer -> TreeModel -> TreeIter -> IO ()

-- | The sizing method the column uses to determine its width. Please note
--   that <i><tt>gTKTREEVIEWCOLUMNAUTOSIZE</tt></i> are inefficient for
--   large views, and can make columns appear choppy.
data () => TreeViewColumnSizing

-- | Columns only get bigger in reaction to changes in the model
TreeViewColumnSizingGrowOnly :: TreeViewColumnSizing

-- | Columns resize to be the optimal size everytime the model changes.
TreeViewColumnSizingAutosize :: TreeViewColumnSizing

-- | Columns are a fixed numbers of pixels wide.
TreeViewColumnSizingFixed :: TreeViewColumnSizing

-- | Catch-all for unknown values
AnotherTreeViewColumnSizing :: Int -> TreeViewColumnSizing

-- | Memory-managed wrapper type.
newtype () => TreeStore
TreeStore :: ManagedPtr TreeStore -> TreeStore

-- | Memory-managed wrapper type.
newtype () => ListStore
ListStore :: ManagedPtr ListStore -> ListStore

-- | A function used for checking whether a row in <i><tt>model</tt></i>
--   matches a search key string entered by the user. Note the return value
--   is reversed from what you would normally expect, though it has some
--   similarity to <tt><i>strcmp()</i></tt> returning 0 for equal strings.
type TreeViewSearchEqualFunc = TreeModel -> Int32 -> Text -> TreeIter -> IO Bool

-- | <i>No description available in the introspection data.</i>
data () => MovementStep

-- | Move forward or back by graphemes
MovementStepLogicalPositions :: MovementStep

-- | Move left or right by graphemes
MovementStepVisualPositions :: MovementStep

-- | Move forward or back by words
MovementStepWords :: MovementStep

-- | Move up or down lines (wrapped lines)
MovementStepDisplayLines :: MovementStep

-- | Move to either end of a line
MovementStepDisplayLineEnds :: MovementStep

-- | Move up or down paragraphs (newline-ended lines)
MovementStepParagraphs :: MovementStep

-- | Move to either end of a paragraph
MovementStepParagraphEnds :: MovementStep

-- | Move by pages
MovementStepPages :: MovementStep

-- | Move to ends of the buffer
MovementStepBufferEnds :: MovementStep

-- | Move horizontally by pages
MovementStepHorizontalPages :: MovementStep

-- | Catch-all for unknown values
AnotherMovementStep :: Int -> MovementStep

-- | Used to indicate which grid lines to draw in a tree view.
data () => TreeViewGridLines

-- | No grid lines.
TreeViewGridLinesNone :: TreeViewGridLines

-- | Horizontal grid lines.
TreeViewGridLinesHorizontal :: TreeViewGridLines

-- | Vertical grid lines.
TreeViewGridLinesVertical :: TreeViewGridLines

-- | Horizontal and vertical grid lines.
TreeViewGridLinesBoth :: TreeViewGridLines

-- | Catch-all for unknown values
AnotherTreeViewGridLines :: Int -> TreeViewGridLines

-- | Function type for determining whether the row pointed to by
--   <i><tt>iter</tt></i> should be rendered as a separator. A common way
--   to implement this is to have a boolean column in the model, whose
--   values the <a>TreeViewRowSeparatorFunc</a> returns.
type TreeViewRowSeparatorFunc = TreeModel -> TreeIter -> IO Bool

-- | A function which decides whether the row indicated by
--   <i><tt>iter</tt></i> is visible.
type TreeModelFilterVisibleFunc = TreeModel -> TreeIter -> IO Bool

-- | Memory-managed wrapper type.
newtype () => ToolItem
ToolItem :: ManagedPtr ToolItem -> ToolItem

-- | Used to customize the appearance of a <a>Toolbar</a>. Note that
--   setting the toolbar style overrides the user’s preferences for the
--   default toolbar style. Note that if the button has only a label set
--   and GTK_TOOLBAR_ICONS is used, the label will be visible, and vice
--   versa.
data () => ToolbarStyle

-- | Buttons display only icons in the toolbar.
ToolbarStyleIcons :: ToolbarStyle

-- | Buttons display only text labels in the toolbar.
ToolbarStyleText :: ToolbarStyle

-- | Buttons display text and icons in the toolbar.
ToolbarStyleBoth :: ToolbarStyle

-- | Buttons display icons and text alongside each other, rather than
--   vertically stacked
ToolbarStyleBothHoriz :: ToolbarStyle

-- | Catch-all for unknown values
AnotherToolbarStyle :: Int -> ToolbarStyle

-- | Represents the orientation of widgets and other objects which can be
--   switched between horizontal and vertical orientation on the fly, like
--   <a>Toolbar</a> or <a>GesturePan</a>.
data () => Orientation

-- | The element is in horizontal orientation.
OrientationHorizontal :: Orientation

-- | The element is in vertical orientation.
OrientationVertical :: Orientation

-- | Catch-all for unknown values
AnotherOrientation :: Int -> Orientation

-- | Memory-managed wrapper type.
newtype () => ToolItemGroup
ToolItemGroup :: ManagedPtr ToolItemGroup -> ToolItemGroup

-- | Flags used to specify the supported drag targets.
data () => ToolPaletteDragTargets

-- | Support drag of items.
ToolPaletteDragTargetsItems :: ToolPaletteDragTargets

-- | Support drag of groups.
ToolPaletteDragTargetsGroups :: ToolPaletteDragTargets

-- | Catch-all for unknown values
AnotherToolPaletteDragTargets :: Int -> ToolPaletteDragTargets

-- | Indicated the relief to be drawn around a <a>Button</a>.
data () => ReliefStyle

-- | Draw a normal relief.
ReliefStyleNormal :: ReliefStyle

-- | A half relief. Deprecated in 3.14, does the same as
--   <i><tt>gTKRELIEFNORMAL</tt></i>
ReliefStyleHalf :: ReliefStyle

-- | No relief.
ReliefStyleNone :: ReliefStyle

-- | Catch-all for unknown values
AnotherReliefStyle :: Int -> ReliefStyle

-- | Memory-managed wrapper type.
newtype () => MenuItem
MenuItem :: ManagedPtr MenuItem -> MenuItem

-- | Memory-managed wrapper type.
newtype () => ToolButton
ToolButton :: ManagedPtr ToolButton -> ToolButton

-- | Memory-managed wrapper type.
newtype () => ToolShell
ToolShell :: ManagedPtr ToolShell -> ToolShell

-- | Memory-managed wrapper type.
newtype () => SizeGroup
SizeGroup :: ManagedPtr SizeGroup -> SizeGroup

-- | Memory-managed wrapper type.
newtype () => StackSwitcher
StackSwitcher :: ManagedPtr StackSwitcher -> StackSwitcher

-- | Memory-managed wrapper type.
newtype () => CheckButton
CheckButton :: ManagedPtr CheckButton -> CheckButton

-- | Memory-managed wrapper type.
newtype () => RadioButton
RadioButton :: ManagedPtr RadioButton -> RadioButton

-- | Memory-managed wrapper type.
newtype () => TextIter
TextIter :: ManagedPtr TextIter -> TextIter

-- | <i>No description available in the introspection data.</i>
data () => ScrollStep

-- | Scroll in steps.
ScrollStepSteps :: ScrollStep

-- | Scroll by pages.
ScrollStepPages :: ScrollStep

-- | Scroll to ends.
ScrollStepEnds :: ScrollStep

-- | Scroll in horizontal steps.
ScrollStepHorizontalSteps :: ScrollStep

-- | Scroll by horizontal pages.
ScrollStepHorizontalPages :: ScrollStep

-- | Scroll to the horizontal ends.
ScrollStepHorizontalEnds :: ScrollStep

-- | Catch-all for unknown values
AnotherScrollStep :: Int -> ScrollStep

-- | See also: <a>Entry::deleteFromCursor</a>.
data () => DeleteType

-- | Delete characters.
DeleteTypeChars :: DeleteType

-- | Delete only the portion of the word to the left/right of cursor if
--   we’re in the middle of a word.
DeleteTypeWordEnds :: DeleteType

-- | Delete words.
DeleteTypeWords :: DeleteType

-- | Delete display-lines. Display-lines refers to the visible lines, with
--   respect to to the current line breaks. As opposed to paragraphs, which
--   are defined by line breaks in the input.
DeleteTypeDisplayLines :: DeleteType

-- | Delete only the portion of the display-line to the left/right of
--   cursor.
DeleteTypeDisplayLineEnds :: DeleteType

-- | Delete to the end of the paragraph. Like C-k in Emacs (or its
--   reverse).
DeleteTypeParagraphEnds :: DeleteType

-- | Delete entire line. Like C-k in pico.
DeleteTypeParagraphs :: DeleteType

-- | Delete only whitespace. Like M-\ in Emacs.
DeleteTypeWhitespace :: DeleteType

-- | Catch-all for unknown values
AnotherDeleteType :: Int -> DeleteType

-- | Memory-managed wrapper type.
newtype () => TextChildAnchor
TextChildAnchor :: ManagedPtr TextChildAnchor -> TextChildAnchor

-- | Used to reference the parts of <a>TextView</a>.
data () => TextWindowType

-- | Invalid value, used as a marker
TextWindowTypePrivate :: TextWindowType

-- | Window that floats over scrolling areas.
TextWindowTypeWidget :: TextWindowType

-- | Scrollable text window.
TextWindowTypeText :: TextWindowType

-- | Left side border window.
TextWindowTypeLeft :: TextWindowType

-- | Right side border window.
TextWindowTypeRight :: TextWindowType

-- | Top border window.
TextWindowTypeTop :: TextWindowType

-- | Bottom border window.
TextWindowTypeBottom :: TextWindowType

-- | Catch-all for unknown values
AnotherTextWindowType :: Int -> TextWindowType

-- | Memory-managed wrapper type.
newtype () => TextAttributes
TextAttributes :: ManagedPtr TextAttributes -> TextAttributes

-- | Describes a type of line wrapping.
data () => WrapMode

-- | do not wrap lines; just make the text area wider
WrapModeNone :: WrapMode

-- | wrap text, breaking lines anywhere the cursor can appear (between
--   characters, usually - if you want to be technical, between graphemes,
--   see <a>getLogAttrs</a>)
WrapModeChar :: WrapMode

-- | wrap text, breaking lines in between words
WrapModeWord :: WrapMode

-- | wrap text, breaking lines in between words, or if that is not enough,
--   also between graphemes
WrapModeWordChar :: WrapMode

-- | Catch-all for unknown values
AnotherWrapMode :: Int -> WrapMode

-- | Memory-managed wrapper type.
newtype () => TextTagTable
TextTagTable :: ManagedPtr TextTagTable -> TextTagTable

-- | These values are used as “info” for the targets contained in the lists
--   returned by <a>textBufferGetCopyTargetList</a> and
--   <a>textBufferGetPasteTargetList</a>.
--   
--   The values counts down from <tt>-1</tt> to avoid clashes with
--   application added drag destinations which usually start at 0.
data () => TextBufferTargetInfo

-- | Buffer contents
TextBufferTargetInfoBufferContents :: TextBufferTargetInfo

-- | Rich text
TextBufferTargetInfoRichText :: TextBufferTargetInfo

-- | Text
TextBufferTargetInfoText :: TextBufferTargetInfo

-- | Catch-all for unknown values
AnotherTextBufferTargetInfo :: Int -> TextBufferTargetInfo

-- | Denotes the expansion properties that a widget will have when it (or
--   its parent) is resized.
data () => AttachOptions

-- | the widget should expand to take up any extra space in its container
--   that has been allocated.
AttachOptionsExpand :: AttachOptions

-- | the widget should shrink as and when possible.
AttachOptionsShrink :: AttachOptions

-- | the widget should fill the space allocated to it.
AttachOptionsFill :: AttachOptions

-- | Catch-all for unknown values
AnotherAttachOptions :: Int -> AttachOptions

-- | Memory-managed wrapper type.
newtype () => SymbolicColor
SymbolicColor :: ManagedPtr SymbolicColor -> SymbolicColor

-- | Scrolling types.
data () => ScrollType

-- | No scrolling.
ScrollTypeNone :: ScrollType

-- | Jump to new location.
ScrollTypeJump :: ScrollType

-- | Step backward.
ScrollTypeStepBackward :: ScrollType

-- | Step forward.
ScrollTypeStepForward :: ScrollType

-- | Page backward.
ScrollTypePageBackward :: ScrollType

-- | Page forward.
ScrollTypePageForward :: ScrollType

-- | Step up.
ScrollTypeStepUp :: ScrollType

-- | Step down.
ScrollTypeStepDown :: ScrollType

-- | Page up.
ScrollTypePageUp :: ScrollType

-- | Page down.
ScrollTypePageDown :: ScrollType

-- | Step to the left.
ScrollTypeStepLeft :: ScrollType

-- | Step to the right.
ScrollTypeStepRight :: ScrollType

-- | Page to the left.
ScrollTypePageLeft :: ScrollType

-- | Page to the right.
ScrollTypePageRight :: ScrollType

-- | Scroll to start.
ScrollTypeStart :: ScrollType

-- | Scroll to end.
ScrollTypeEnd :: ScrollType

-- | Catch-all for unknown values
AnotherScrollType :: Int -> ScrollType

-- | The spin button update policy determines whether the spin button
--   displays values even if they are outside the bounds of its adjustment.
--   See <a>spinButtonSetUpdatePolicy</a>.
data () => SpinButtonUpdatePolicy

-- | When refreshing your <a>SpinButton</a>, the value is always displayed
SpinButtonUpdatePolicyAlways :: SpinButtonUpdatePolicy

-- | When refreshing your <a>SpinButton</a>, the value is only displayed if
--   it is valid within the bounds of the spin button's adjustment
SpinButtonUpdatePolicyIfValid :: SpinButtonUpdatePolicy

-- | Catch-all for unknown values
AnotherSpinButtonUpdatePolicy :: Int -> SpinButtonUpdatePolicy

-- | The values of the GtkSpinType enumeration are used to specify the
--   change to make in <a>spinButtonSpin</a>.
data () => SpinType

-- | Increment by the adjustments step increment.
SpinTypeStepForward :: SpinType

-- | Decrement by the adjustments step increment.
SpinTypeStepBackward :: SpinType

-- | Increment by the adjustments page increment.
SpinTypePageForward :: SpinType

-- | Decrement by the adjustments page increment.
SpinTypePageBackward :: SpinType

-- | Go to the adjustments lower bound.
SpinTypeHome :: SpinType

-- | Go to the adjustments upper bound.
SpinTypeEnd :: SpinType

-- | Change by a specified amount.
SpinTypeUserDefined :: SpinType

-- | Catch-all for unknown values
AnotherSpinType :: Int -> SpinType

-- | The mode of the size group determines the directions in which the size
--   group affects the requested sizes of its component widgets.
data () => SizeGroupMode

-- | group has no effect
SizeGroupModeNone :: SizeGroupMode

-- | group affects horizontal requisition
SizeGroupModeHorizontal :: SizeGroupMode

-- | group affects vertical requisition
SizeGroupModeVertical :: SizeGroupMode

-- | group affects both horizontal and vertical requisition
SizeGroupModeBoth :: SizeGroupMode

-- | Catch-all for unknown values
AnotherSizeGroupMode :: Int -> SizeGroupMode

-- | Memory-managed wrapper type.
newtype () => SearchBar
SearchBar :: ManagedPtr SearchBar -> SearchBar

-- | Memory-managed wrapper type.
newtype () => Viewport
Viewport :: ManagedPtr Viewport -> Viewport

-- | Memory-managed wrapper type.
newtype () => Scrollable
Scrollable :: ManagedPtr Scrollable -> Scrollable

-- | Specifies which corner a child widget should be placed in when packed
--   into a <a>ScrolledWindow</a>. This is effectively the opposite of
--   where the scroll bars are placed.
data () => CornerType

-- | Place the scrollbars on the right and bottom of the widget (default
--   behaviour).
CornerTypeTopLeft :: CornerType

-- | Place the scrollbars on the top and right of the widget.
CornerTypeBottomLeft :: CornerType

-- | Place the scrollbars on the left and bottom of the widget.
CornerTypeTopRight :: CornerType

-- | Place the scrollbars on the top and left of the widget.
CornerTypeBottomRight :: CornerType

-- | Catch-all for unknown values
AnotherCornerType :: Int -> CornerType

-- | Determines how the size should be computed to achieve the one of the
--   visibility mode for the scrollbars.
data () => PolicyType

-- | The scrollbar is always visible. The view size is independent of the
--   content.
PolicyTypeAlways :: PolicyType

-- | The scrollbar will appear and disappear as necessary. For example,
--   when all of a <a>TreeView</a> can not be seen.
PolicyTypeAutomatic :: PolicyType

-- | The scrollbar should never appear. In this mode the content determines
--   the size.
PolicyTypeNever :: PolicyType

-- | Don't show a scrollbar, but don't force the size to follow the
--   content. This can be used e.g. to make multiple scrolled windows share
--   a scrollbar. Since: 3.16
PolicyTypeExternal :: PolicyType

-- | Catch-all for unknown values
AnotherPolicyType :: Int -> PolicyType

-- | See also <a>printSettingsSetDuplex</a>.
data () => PrintDuplex

-- | No duplex.
PrintDuplexSimplex :: PrintDuplex

-- | Horizontal duplex.
PrintDuplexHorizontal :: PrintDuplex

-- | Vertical duplex.
PrintDuplexVertical :: PrintDuplex

-- | Catch-all for unknown values
AnotherPrintDuplex :: Int -> PrintDuplex

-- | Used to determine the layout of pages on a sheet when printing
--   multiple pages per sheet.
data () => NumberUpLayout

NumberUpLayoutLrtb :: NumberUpLayout

NumberUpLayoutLrbt :: NumberUpLayout

NumberUpLayoutRltb :: NumberUpLayout

NumberUpLayoutRlbt :: NumberUpLayout

NumberUpLayoutTblr :: NumberUpLayout

NumberUpLayoutTbrl :: NumberUpLayout

NumberUpLayoutBtlr :: NumberUpLayout

NumberUpLayoutBtrl :: NumberUpLayout

-- | Catch-all for unknown values
AnotherNumberUpLayout :: Int -> NumberUpLayout

-- | See also <tt><i>gtk_print_job_set_page_set()</i></tt>.
data () => PageSet

-- | All pages.
PageSetAll :: PageSet

-- | Even pages.
PageSetEven :: PageSet

-- | Odd pages.
PageSetOdd :: PageSet

-- | Catch-all for unknown values
AnotherPageSet :: Int -> PageSet

-- | See also <tt><i>gtk_print_job_set_pages()</i></tt>
data () => PrintPages

-- | All pages.
PrintPagesAll :: PrintPages

-- | Current page.
PrintPagesCurrent :: PrintPages

-- | Range of pages.
PrintPagesRanges :: PrintPages

-- | Selected pages.
PrintPagesSelection :: PrintPages

-- | Catch-all for unknown values
AnotherPrintPages :: Int -> PrintPages

-- | See also <a>printSettingsSetQuality</a>.
data () => PrintQuality

-- | Low quality.
PrintQualityLow :: PrintQuality

-- | Normal quality.
PrintQualityNormal :: PrintQuality

-- | High quality.
PrintQualityHigh :: PrintQuality

-- | Draft quality.
PrintQualityDraft :: PrintQuality

-- | Catch-all for unknown values
AnotherPrintQuality :: Int -> PrintQuality

-- | The status gives a rough indication of the completion of a running
--   print operation.
data () => PrintStatus

-- | The printing has not started yet; this status is set initially, and
--   while the print dialog is shown.
PrintStatusInitial :: PrintStatus

-- | This status is set while the begin-print signal is emitted and during
--   pagination.
PrintStatusPreparing :: PrintStatus

-- | This status is set while the pages are being rendered.
PrintStatusGeneratingData :: PrintStatus

-- | The print job is being sent off to the printer.
PrintStatusSendingData :: PrintStatus

-- | The print job has been sent to the printer, but is not printed for
--   some reason, e.g. the printer may be stopped.
PrintStatusPending :: PrintStatus

-- | Some problem has occurred during printing, e.g. a paper jam.
PrintStatusPendingIssue :: PrintStatus

-- | The printer is processing the print job.
PrintStatusPrinting :: PrintStatus

-- | The printing has been completed successfully.
PrintStatusFinished :: PrintStatus

-- | The printing has been aborted.
PrintStatusFinishedAborted :: PrintStatus

-- | Catch-all for unknown values
AnotherPrintStatus :: Int -> PrintStatus

-- | Memory-managed wrapper type.
newtype () => Statusbar
Statusbar :: ManagedPtr Statusbar -> Statusbar

-- | Memory-managed wrapper type.
newtype () => PrintOperationPreview
PrintOperationPreview :: ManagedPtr PrintOperationPreview -> PrintOperationPreview

-- | Memory-managed wrapper type.
newtype () => PrintSettings
PrintSettings :: ManagedPtr PrintSettings -> PrintSettings

-- | Memory-managed wrapper type.
newtype () => ApplicationWindow
ApplicationWindow :: ManagedPtr ApplicationWindow -> ApplicationWindow

-- | Memory-managed wrapper type.
newtype () => MenuShell
MenuShell :: ManagedPtr MenuShell -> MenuShell

-- | Memory-managed wrapper type.
newtype () => Popover
Popover :: ManagedPtr Popover -> Popover

-- | Memory-managed wrapper type.
newtype () => MountOperation
MountOperation :: ManagedPtr MountOperation -> MountOperation

-- | These flags serve two purposes. First, the application can call
--   <a>placesSidebarSetOpenFlags</a> using these flags as a bitmask. This
--   tells the sidebar that the application is able to open folders
--   selected from the sidebar in various ways, for example, in new tabs or
--   in new windows in addition to the normal mode.
--   
--   Second, when one of these values gets passed back to the application
--   in the <a>PlacesSidebar::openLocation</a> signal, it means that the
--   application should open the selected location in the normal way, in a
--   new tab, or in a new window. The sidebar takes care of determining the
--   desired way to open the location, based on the modifier keys that the
--   user is pressing at the time the selection is made.
--   
--   If the application never calls <a>placesSidebarSetOpenFlags</a>, then
--   the sidebar will only use <tt><i>GTK_PLACES_OPEN_NORMAL</i></tt> in
--   the <a>PlacesSidebar::openLocation</a> signal. This is the default
--   mode of operation.
data () => PlacesOpenFlags

-- | This is the default mode that <a>PlacesSidebar</a> uses if no other
--   flags are specified. It indicates that the calling application should
--   open the selected location in the normal way, for example, in the
--   folder view beside the sidebar.
PlacesOpenFlagsNormal :: PlacesOpenFlags

-- | When passed to <a>placesSidebarSetOpenFlags</a>, this indicates that
--   the application can open folders selected from the sidebar in new
--   tabs. This value will be passed to the
--   <a>PlacesSidebar::openLocation</a> signal when the user selects that a
--   location be opened in a new tab instead of in the standard fashion.
PlacesOpenFlagsNewTab :: PlacesOpenFlags

-- | Similar to <i><tt>gTKPLACESOPENNEWTAB</tt></i>, but indicates that the
--   application can open folders in new windows.
PlacesOpenFlagsNewWindow :: PlacesOpenFlags

-- | Catch-all for unknown values
AnotherPlacesOpenFlags :: Int -> PlacesOpenFlags

-- | Memory-managed wrapper type.
newtype () => PadActionEntry
PadActionEntry :: ManagedPtr PadActionEntry -> PadActionEntry

-- | Memory-managed wrapper type.
newtype () => Dialog
Dialog :: ManagedPtr Dialog -> Dialog

-- | Memory-managed wrapper type.
newtype () => MenuBar
MenuBar :: ManagedPtr MenuBar -> MenuBar

-- | Used to indicate the direction in which an arrow should point.
data () => ArrowType

-- | Represents an upward pointing arrow.
ArrowTypeUp :: ArrowType

-- | Represents a downward pointing arrow.
ArrowTypeDown :: ArrowType

-- | Represents a left pointing arrow.
ArrowTypeLeft :: ArrowType

-- | Represents a right pointing arrow.
ArrowTypeRight :: ArrowType

-- | No arrow. Since 2.10.
ArrowTypeNone :: ArrowType

-- | Catch-all for unknown values
AnotherArrowType :: Int -> ArrowType

-- | Determines how widgets should be packed inside menubars and menuitems
--   contained in menubars.
data () => PackDirection

-- | Widgets are packed left-to-right
PackDirectionLtr :: PackDirection

-- | Widgets are packed right-to-left
PackDirectionRtl :: PackDirection

-- | Widgets are packed top-to-bottom
PackDirectionTtb :: PackDirection

-- | Widgets are packed bottom-to-top
PackDirectionBtt :: PackDirection

-- | Catch-all for unknown values
AnotherPackDirection :: Int -> PackDirection

-- | A user function supplied when calling <a>menuPopup</a> which controls
--   the positioning of the menu when it is displayed. The function sets
--   the <i><tt>x</tt></i> and <i><tt>y</tt></i> parameters to the
--   coordinates where the menu is to be drawn. To make the menu appear on
--   a different monitor than the mouse pointer, <a>menuSetMonitor</a> must
--   be called.
type MenuPositionFunc = Menu -> Int32 -> Int32 -> IO (Int32, Int32, Bool)

-- | Whenever <i><tt>row</tt></i> changes or which row is before
--   <i><tt>row</tt></i> changes this is called, which lets you update the
--   header on <i><tt>row</tt></i>. You may remove or set a new one via
--   <a>listBoxRowSetHeader</a> or just change the state of the current
--   header widget.
--   
--   <i>Since: 3.10</i>
type ListBoxUpdateHeaderFunc = ListBoxRow -> Maybe ListBoxRow -> IO ()

-- | Used to control what selections users are allowed to make.
data () => SelectionMode

-- | No selection is possible.
SelectionModeNone :: SelectionMode

-- | Zero or one element may be selected.
SelectionModeSingle :: SelectionMode

-- | Exactly one element is selected. In some circumstances, such as
--   initially or during a search operation, it’s possible for no element
--   to be selected with <a>SelectionModeBrowse</a>. What is really
--   enforced is that the user can’t deselect a currently selected element
--   except by selecting another element.
SelectionModeBrowse :: SelectionMode

-- | Any number of elements may be selected. The Ctrl key may be used to
--   enlarge the selection, and Shift key to select between the focus and
--   the child pointed to. Some widgets may also allow Click-drag to select
--   a range of elements.
SelectionModeMultiple :: SelectionMode

-- | Catch-all for unknown values
AnotherSelectionMode :: Int -> SelectionMode

-- | Describes how <a>LevelBar</a> contents should be rendered. Note that
--   this enumeration could be extended with additional modes in the
--   future.
--   
--   <i>Since: 3.6</i>
data () => LevelBarMode

-- | the bar has a continuous mode
LevelBarModeContinuous :: LevelBarMode

-- | the bar has a discrete mode
LevelBarModeDiscrete :: LevelBarMode

-- | Catch-all for unknown values
AnotherLevelBarMode :: Int -> LevelBarMode

-- | Used for justifying the text inside a <a>Label</a> widget. (See also
--   <a>Alignment</a>).
data () => Justification

-- | The text is placed at the left edge of the label.
JustificationLeft :: Justification

-- | The text is placed at the right edge of the label.
JustificationRight :: Justification

-- | The text is placed in the center of the label.
JustificationCenter :: Justification

-- | The text is placed is distributed across the label.
JustificationFill :: Justification

-- | Catch-all for unknown values
AnotherJustification :: Int -> Justification

-- | The type of message being displayed in the dialog.
data () => MessageType

-- | Informational message
MessageTypeInfo :: MessageType

-- | Non-fatal warning message
MessageTypeWarning :: MessageType

-- | Question requiring a choice
MessageTypeQuestion :: MessageType

-- | Fatal error message
MessageTypeError :: MessageType

-- | None of the above
MessageTypeOther :: MessageType

-- | Catch-all for unknown values
AnotherMessageType :: Int -> MessageType

-- | Memory-managed wrapper type.
newtype () => IconInfo
IconInfo :: ManagedPtr IconInfo -> IconInfo

-- | Whenever a container has some form of natural row it may align
--   children in that row along a common typographical baseline. If the
--   amount of verical space in the row is taller than the total requested
--   height of the baseline-aligned children then it can use a
--   <a>BaselinePosition</a> to select where to put the baseline inside the
--   extra availible space.
--   
--   <i>Since: 3.10</i>
data () => BaselinePosition

-- | Align the baseline at the top
BaselinePositionTop :: BaselinePosition

-- | Center the baseline
BaselinePositionCenter :: BaselinePosition

-- | Align the baseline at the bottom
BaselinePositionBottom :: BaselinePosition

-- | Catch-all for unknown values
AnotherBaselinePosition :: Int -> BaselinePosition

-- | Used to change the appearance of an outline typically provided by a
--   <a>Frame</a>.
--   
--   Note that many themes do not differentiate the appearance of the
--   various shadow types: Either their is no visible shadow
--   (<i><tt>gTKSHADOWNONE</tt></i>), or there is (any other value).
data () => ShadowType

-- | No outline.
ShadowTypeNone :: ShadowType

-- | The outline is bevelled inwards.
ShadowTypeIn :: ShadowType

-- | The outline is bevelled outwards like a button.
ShadowTypeOut :: ShadowType

-- | The outline has a sunken 3d appearance.
ShadowTypeEtchedIn :: ShadowType

-- | The outline has a raised 3d appearance.
ShadowTypeEtchedOut :: ShadowType

-- | Catch-all for unknown values
AnotherShadowType :: Int -> ShadowType

-- | Memory-managed wrapper type.
newtype () => FontSelection
FontSelection :: ManagedPtr FontSelection -> FontSelection

-- | Memory-managed wrapper type.
newtype () => FileChooserDialog
FileChooserDialog :: ManagedPtr FileChooserDialog -> FileChooserDialog

-- | A function which decides whether the row indicated by
--   <i><tt>iter</tt></i> matches a given <i><tt>key</tt></i>, and should
--   be displayed as a possible completion for <i><tt>key</tt></i>. Note
--   that <i><tt>key</tt></i> is normalized and case-folded (see
--   <a>utf8Normalize</a> and <a>utf8Casefold</a>). If this is not
--   appropriate, match functions have access to the unmodified key via
--   <tt>gtk_entry_get_text (GTK_ENTRY (gtk_entry_completion_get_entry
--   ()))</tt>.
type EntryCompletionMatchFunc = EntryCompletion -> Text -> TreeIter -> IO Bool

-- | Memory-managed wrapper type.
newtype () => EntryBuffer
EntryBuffer :: ManagedPtr EntryBuffer -> EntryBuffer

-- | Memory-managed wrapper type.
newtype () => Grid
Grid :: ManagedPtr Grid -> Grid

-- | Memory-managed wrapper type.
newtype () => ColorSelection
ColorSelection :: ManagedPtr ColorSelection -> ColorSelection

-- | Memory-managed wrapper type.
newtype () => RadioMenuItem
RadioMenuItem :: ManagedPtr RadioMenuItem -> RadioMenuItem

-- | Memory-managed wrapper type.
newtype () => CellAreaContext
CellAreaContext :: ManagedPtr CellAreaContext -> CellAreaContext

-- | Memory-managed wrapper type.
newtype () => CellRendererPixbuf
CellRendererPixbuf :: ManagedPtr CellRendererPixbuf -> CellRendererPixbuf

-- | Memory-managed wrapper type.
newtype () => CellRendererToggle
CellRendererToggle :: ManagedPtr CellRendererToggle -> CellRendererToggle

-- | Tells how a cell is to be rendered.
data () => CellRendererState

-- | The cell is currently selected, and probably has a selection colored
--   background to render to.
CellRendererStateSelected :: CellRendererState

-- | The mouse is hovering over the cell.
CellRendererStatePrelit :: CellRendererState

-- | The cell is drawn in an insensitive manner
CellRendererStateInsensitive :: CellRendererState

-- | The cell is in a sorted row
CellRendererStateSorted :: CellRendererState

-- | The cell is in the focus row.
CellRendererStateFocused :: CellRendererState

-- | The cell is in a row that can be expanded. Since 3.4
CellRendererStateExpandable :: CellRendererState

-- | The cell is in a row that is expanded. Since 3.4
CellRendererStateExpanded :: CellRendererState

-- | Catch-all for unknown values
AnotherCellRendererState :: Int -> CellRendererState

-- | Memory-managed wrapper type.
newtype () => CellEditable
CellEditable :: ManagedPtr CellEditable -> CellEditable

-- | The type of the callback functions used for iterating over the cell
--   renderers of a <a>CellArea</a>, see <a>cellAreaForeach</a>.
type CellCallback = CellRenderer -> IO Bool

-- | The type of the callback functions used for iterating over the cell
--   renderers and their allocated areas inside a <a>CellArea</a>, see
--   <a>cellAreaForeachAlloc</a>.
type CellAllocCallback = CellRenderer -> Rectangle -> Rectangle -> IO Bool

-- | Memory-managed wrapper type.
newtype () => Misc
Misc :: ManagedPtr Misc -> Misc

-- | Memory-managed wrapper type.
newtype () => Buildable
Buildable :: ManagedPtr Buildable -> Buildable

-- | A function used by <a>assistantSetForwardPageFunc</a> to know which is
--   the next page given a current one. It’s called both for computing the
--   next page when the user presses the “forward” button and for handling
--   the behavior of the “last” button.
type AssistantPageFunc = Int32 -> IO Int32

-- | Memory-managed wrapper type.
newtype () => ShortcutsWindow
ShortcutsWindow :: ManagedPtr ShortcutsWindow -> ShortcutsWindow

-- | Memory-managed wrapper type.
newtype () => AppChooserWidget
AppChooserWidget :: ManagedPtr AppChooserWidget -> AppChooserWidget

-- | Memory-managed wrapper type.
newtype () => AppChooserDialog
AppChooserDialog :: ManagedPtr AppChooserDialog -> AppChooserDialog

-- | Memory-managed wrapper type.
newtype () => Activatable
Activatable :: ManagedPtr Activatable -> Activatable

-- | <i>No description available in the introspection data.</i>
type AccelMapForeach = Ptr () -> Text -> Word32 -> [ModifierType] -> Bool -> IO ()

-- | Memory-managed wrapper type.
newtype () => AccelLabel
AccelLabel :: ManagedPtr AccelLabel -> AccelLabel

-- | <i>No description available in the introspection data.</i>
type AccelGroupActivate = AccelGroup -> Object -> Word32 -> [ModifierType] -> IO Bool

-- | Memory-managed wrapper type.
newtype () => AccelKey
AccelKey :: ManagedPtr AccelKey -> AccelKey

-- | Memory-managed wrapper type.
newtype () => AccelGroupEntry
AccelGroupEntry :: ManagedPtr AccelGroupEntry -> AccelGroupEntry

-- | These flags indicate various properties of a <a>TreeModel</a>.
--   
--   They are returned by <a>treeModelGetFlags</a>, and must be static for
--   the lifetime of the object. A more complete description of
--   <tt><i>GTK_TREE_MODEL_ITERS_PERSIST</i></tt> can be found in the
--   overview of this section.
data () => TreeModelFlags

-- | iterators survive all signals emitted by the tree
TreeModelFlagsItersPersist :: TreeModelFlags

-- | the model is a list only, and never has children
TreeModelFlagsListOnly :: TreeModelFlags

-- | Catch-all for unknown values
AnotherTreeModelFlags :: Int -> TreeModelFlags

-- | Memory-managed wrapper type.
newtype () => RecentFilter
RecentFilter :: ManagedPtr RecentFilter -> RecentFilter

-- | The type of function that is used for deciding what fonts get shown in
--   a <a>FontChooser</a>. See <a>fontChooserSetFilterFunc</a>.
type FontFilterFunc = FontFamily -> FontFace -> IO Bool

-- | Used as a return value of handlers for the
--   <a>FileChooser::confirmOverwrite</a> signal of a <a>FileChooser</a>.
--   This value determines whether the file chooser will present the stock
--   confirmation dialog, accept the user’s choice of a filename, or let
--   the user choose another filename.
--   
--   <i>Since: 2.8</i>
data () => FileChooserConfirmation

-- | The file chooser will present its stock dialog to confirm about
--   overwriting an existing file.
FileChooserConfirmationConfirm :: FileChooserConfirmation

-- | The file chooser will terminate and accept the user’s choice of a file
--   name.
FileChooserConfirmationAcceptFilename :: FileChooserConfirmation

-- | The file chooser will continue running, so as to let the user select
--   another file name.
FileChooserConfirmationSelectAgain :: FileChooserConfirmation

-- | Catch-all for unknown values
AnotherFileChooserConfirmation :: Int -> FileChooserConfirmation

-- | Memory-managed wrapper type.
newtype () => FileFilter
FileFilter :: ManagedPtr FileFilter -> FileFilter

-- | A function which should set the value of <i><tt>cellLayout</tt></i>’s
--   cell renderer(s) as appropriate.
type CellLayoutDataFunc = CellLayout -> CellRenderer -> TreeModel -> TreeIter -> IO ()

-- | Memory-managed wrapper type.
newtype () => Action
Action :: ManagedPtr Action -> Action

-- | Memory-managed wrapper type.
newtype () => TreeDragDest
TreeDragDest :: ManagedPtr TreeDragDest -> TreeDragDest

-- | Memory-managed wrapper type.
newtype () => Expander
Expander :: ManagedPtr Expander -> Expander

-- | Memory-managed wrapper type.
newtype () => Spinner
Spinner :: ManagedPtr Spinner -> Spinner

-- | Priorities for path lookups. See also <a>bindingSetAddPath</a>.
data () => PathPriorityType

-- | Deprecated
PathPriorityTypeLowest :: PathPriorityType

-- | Deprecated
PathPriorityTypeGtk :: PathPriorityType

-- | Deprecated
PathPriorityTypeApplication :: PathPriorityType

-- | Deprecated
PathPriorityTypeTheme :: PathPriorityType

-- | Deprecated
PathPriorityTypeRc :: PathPriorityType

-- | Deprecated
PathPriorityTypeHighest :: PathPriorityType

-- | Catch-all for unknown values
AnotherPathPriorityType :: Int -> PathPriorityType

-- | Memory-managed wrapper type.
newtype () => StockItem
StockItem :: ManagedPtr StockItem -> StockItem

-- | Controls how a widget deals with extra space in a single (x or y)
--   dimension.
--   
--   Alignment only matters if the widget receives a “too large”
--   allocation, for example if you packed the widget with the
--   <a>Widget:expand</a> flag inside a <a>Box</a>, then the widget might
--   get extra space. If you have for example a 16x16 icon inside a 32x32
--   space, the icon could be scaled and stretched, it could be centered,
--   or it could be positioned to one side of the space.
--   
--   Note that in horizontal context <i><tt>gTKALIGNSTART</tt></i> and
--   <i><tt>gTKALIGNEND</tt></i> are interpreted relative to text
--   direction.
--   
--   GTK_ALIGN_BASELINE support for it is optional for containers and
--   widgets, and it is only supported for vertical alignment. When its not
--   supported by a child or a container it is treated as
--   <i><tt>gTKALIGNFILL</tt></i>.
data () => Align

-- | stretch to fill all space if possible, center if no meaningful way to
--   stretch
AlignFill :: Align

-- | snap to left or top side, leaving space on right or bottom
AlignStart :: Align

-- | snap to right or bottom side, leaving space on left or top
AlignEnd :: Align

-- | center natural width of widget inside the allocation
AlignCenter :: Align

-- | align the widget according to the baseline. Since 3.10.
AlignBaseline :: Align

-- | Catch-all for unknown values
AnotherAlign :: Int -> Align

-- | Used to specify the placement of scroll arrows in scrolling menus.
data () => ArrowPlacement

-- | Place one arrow on each end of the menu.
ArrowPlacementBoth :: ArrowPlacement

-- | Place both arrows at the top of the menu.
ArrowPlacementStart :: ArrowPlacement

-- | Place both arrows at the bottom of the menu.
ArrowPlacementEnd :: ArrowPlacement

-- | Catch-all for unknown values
AnotherArrowPlacement :: Int -> ArrowPlacement

-- | An enum for determining the page role inside the <a>Assistant</a>.
--   It's used to handle buttons sensitivity and visibility.
--   
--   Note that an assistant needs to end its page flow with a page of type
--   <a>AssistantPageTypeConfirm</a>, <a>AssistantPageTypeSummary</a> or
--   <a>AssistantPageTypeProgress</a> to be correct.
--   
--   The Cancel button will only be shown if the page isn’t “committed”.
--   See <a>assistantCommit</a> for details.
data () => AssistantPageType

-- | The page has regular contents. Both the Back and forward buttons will
--   be shown.
AssistantPageTypeContent :: AssistantPageType

-- | The page contains an introduction to the assistant task. Only the
--   Forward button will be shown if there is a next page.
AssistantPageTypeIntro :: AssistantPageType

-- | The page lets the user confirm or deny the changes. The Back and Apply
--   buttons will be shown.
AssistantPageTypeConfirm :: AssistantPageType

-- | The page informs the user of the changes done. Only the Close button
--   will be shown.
AssistantPageTypeSummary :: AssistantPageType

-- | Used for tasks that take a long time to complete, blocks the assistant
--   until the page is marked as complete. Only the back button will be
--   shown.
AssistantPageTypeProgress :: AssistantPageType

-- | Used for when other page types are not appropriate. No buttons will be
--   shown, and the application must add its own buttons through
--   <a>assistantAddActionWidget</a>.
AssistantPageTypeCustom :: AssistantPageType

-- | Catch-all for unknown values
AnotherAssistantPageType :: Int -> AssistantPageType

-- | Error codes that identify various errors that can occur while using
--   <a>Builder</a>.
data () => BuilderError

-- | A type-func attribute didn’t name a function that returns a
--   <a>GType</a>.
BuilderErrorInvalidTypeFunction :: BuilderError

-- | The input contained a tag that <a>Builder</a> can’t handle.
BuilderErrorUnhandledTag :: BuilderError

-- | An attribute that is required by <a>Builder</a> was missing.
BuilderErrorMissingAttribute :: BuilderError

-- | <a>Builder</a> found an attribute that it doesn’t understand.
BuilderErrorInvalidAttribute :: BuilderError

-- | <a>Builder</a> found a tag that it doesn’t understand.
BuilderErrorInvalidTag :: BuilderError

-- | A required property value was missing.
BuilderErrorMissingPropertyValue :: BuilderError

-- | <a>Builder</a> couldn’t parse some attribute value.
BuilderErrorInvalidValue :: BuilderError

-- | The input file requires a newer version of GTK+.
BuilderErrorVersionMismatch :: BuilderError

-- | An object id occurred twice.
BuilderErrorDuplicateId :: BuilderError

-- | A specified object type is of the same type or derived from the type
--   of the composite class being extended with builder XML.
BuilderErrorObjectTypeRefused :: BuilderError

-- | The wrong type was specified in a composite class’s template XML
BuilderErrorTemplateMismatch :: BuilderError

-- | The specified property is unknown for the object class.
BuilderErrorInvalidProperty :: BuilderError

-- | The specified signal is unknown for the object class.
BuilderErrorInvalidSignal :: BuilderError

-- | An object id is unknown
BuilderErrorInvalidId :: BuilderError

-- | Catch-all for unknown values
AnotherBuilderError :: Int -> BuilderError

-- | Used to dictate the style that a <a>ButtonBox</a> uses to layout the
--   buttons it contains.
data () => ButtonBoxStyle

-- | Buttons are evenly spread across the box.
ButtonBoxStyleSpread :: ButtonBoxStyle

-- | Buttons are placed at the edges of the box.
ButtonBoxStyleEdge :: ButtonBoxStyle

-- | Buttons are grouped towards the start of the box, (on the left for a
--   HBox, or the top for a VBox).
ButtonBoxStyleStart :: ButtonBoxStyle

-- | Buttons are grouped towards the end of the box, (on the right for a
--   HBox, or the bottom for a VBox).
ButtonBoxStyleEnd :: ButtonBoxStyle

-- | Buttons are centered in the box. Since 2.12.
ButtonBoxStyleCenter :: ButtonBoxStyle

-- | Buttons expand to fill the box. This entails giving buttons a "linked"
--   appearance, making button sizes homogeneous, and setting spacing to 0
--   (same as calling <a>boxSetHomogeneous</a> and <a>boxSetSpacing</a>
--   manually). Since 3.12.
ButtonBoxStyleExpand :: ButtonBoxStyle

-- | Catch-all for unknown values
AnotherButtonBoxStyle :: Int -> ButtonBoxStyle

-- | The role specifies the desired appearance of a <a>ModelButton</a>.
data () => ButtonRole

-- | A plain button
ButtonRoleNormal :: ButtonRole

-- | A check button
ButtonRoleCheck :: ButtonRole

-- | A radio button
ButtonRoleRadio :: ButtonRole

-- | Catch-all for unknown values
AnotherButtonRole :: Int -> ButtonRole

-- | Prebuilt sets of buttons for the dialog. If none of these choices are
--   appropriate, simply use <a>ButtonsTypeNone</a> then call
--   <tt><i>gtk_dialog_add_buttons()</i></tt>.
--   
--   <pre>
--   Please note that 'GI.Gtk.Enums.ButtonsTypeOk', 'GI.Gtk.Enums.ButtonsTypeYesNo'
--   and 'GI.Gtk.Enums.ButtonsTypeOkCancel' are discouraged by the
--   &lt;http://library.gnome.org/devel/hig-book/stable/ GNOME Human Interface Guidelines&gt;.
--   </pre>
data () => ButtonsType

-- | no buttons at all
ButtonsTypeNone :: ButtonsType

-- | an OK button
ButtonsTypeOk :: ButtonsType

-- | a Close button
ButtonsTypeClose :: ButtonsType

-- | a Cancel button
ButtonsTypeCancel :: ButtonsType

-- | Yes and No buttons
ButtonsTypeYesNo :: ButtonsType

-- | OK and Cancel buttons
ButtonsTypeOkCancel :: ButtonsType

-- | Catch-all for unknown values
AnotherButtonsType :: Int -> ButtonsType

-- | Determines if the edited accelerators are GTK+ accelerators. If they
--   are, consumed modifiers are suppressed, only accelerators accepted by
--   GTK+ are allowed, and the accelerators are rendered in the same way as
--   they are in menus.
data () => CellRendererAccelMode

-- | GTK+ accelerators mode
CellRendererAccelModeGtk :: CellRendererAccelMode

-- | Other accelerator mode
CellRendererAccelModeOther :: CellRendererAccelMode

-- | Catch-all for unknown values
AnotherCellRendererAccelMode :: Int -> CellRendererAccelMode

-- | Identifies how the user can interact with a particular cell.
data () => CellRendererMode

-- | The cell is just for display and cannot be interacted with. Note that
--   this doesn’t mean that eg. the row being drawn can’t be selected --
--   just that a particular element of it cannot be individually modified.
CellRendererModeInert :: CellRendererMode

-- | The cell can be clicked.
CellRendererModeActivatable :: CellRendererMode

-- | The cell can be edited or otherwise modified.
CellRendererModeEditable :: CellRendererMode

-- | Catch-all for unknown values
AnotherCellRendererMode :: Int -> CellRendererMode

-- | Error codes for <tt><i>GTK_CSS_PROVIDER_ERROR</i></tt>.
data () => CssProviderError

-- | Failed.
CssProviderErrorFailed :: CssProviderError

-- | Syntax error.
CssProviderErrorSyntax :: CssProviderError

-- | Import error.
CssProviderErrorImport :: CssProviderError

-- | Name error.
CssProviderErrorName :: CssProviderError

-- | Deprecation error.
CssProviderErrorDeprecated :: CssProviderError

-- | Unknown value.
CssProviderErrorUnknownValue :: CssProviderError

-- | Catch-all for unknown values
AnotherCssProviderError :: Int -> CssProviderError

-- | The different types of sections indicate parts of a CSS document as
--   parsed by GTK’s CSS parser. They are oriented towards the <a>CSS
--   Grammar</a>, but may contain extensions.
--   
--   More types might be added in the future as the parser incorporates
--   more features.
--   
--   <i>Since: 3.2</i>
data () => CssSectionType

-- | The section describes a complete document. This section time is the
--   only one where <a>cssSectionGetParent</a> might return <a>Nothing</a>.
CssSectionTypeDocument :: CssSectionType

-- | The section defines an import rule.
CssSectionTypeImport :: CssSectionType

-- | The section defines a color. This is a GTK extension to CSS.
CssSectionTypeColorDefinition :: CssSectionType

-- | The section defines a binding set. This is a GTK extension to CSS.
CssSectionTypeBindingSet :: CssSectionType

-- | The section defines a CSS ruleset.
CssSectionTypeRuleset :: CssSectionType

-- | The section defines a CSS selector.
CssSectionTypeSelector :: CssSectionType

-- | The section defines the declaration of a CSS variable.
CssSectionTypeDeclaration :: CssSectionType

-- | The section defines the value of a CSS declaration.
CssSectionTypeValue :: CssSectionType

-- | The section defines keyframes. See
--   &lt;<a>http://dev.w3.org/csswg/css3-animations/#keyframes</a> CSS
--   Animations&gt; for details. Since 3.6
CssSectionTypeKeyframes :: CssSectionType

-- | Catch-all for unknown values
AnotherCssSectionType :: Int -> CssSectionType

-- | Gives an indication why a drag operation failed. The value can by
--   obtained by connecting to the <a>Widget::dragFailed</a> signal.
data () => DragResult

-- | The drag operation was successful.
DragResultSuccess :: DragResult

-- | No suitable drag target.
DragResultNoTarget :: DragResult

-- | The user cancelled the drag operation.
DragResultUserCancelled :: DragResult

-- | The drag operation timed out.
DragResultTimeoutExpired :: DragResult

-- | The pointer or keyboard grab used for the drag operation was broken.
DragResultGrabBroken :: DragResult

-- | The drag operation failed due to some unspecified error.
DragResultError :: DragResult

-- | Catch-all for unknown values
AnotherDragResult :: Int -> DragResult

-- | Specifies the side of the entry at which an icon is placed.
--   
--   <i>Since: 2.16</i>
data () => EntryIconPosition

-- | At the beginning of the entry (depending on the text direction).
EntryIconPositionPrimary :: EntryIconPosition

-- | At the end of the entry (depending on the text direction).
EntryIconPositionSecondary :: EntryIconPosition

-- | Catch-all for unknown values
AnotherEntryIconPosition :: Int -> EntryIconPosition

-- | Describes the state of a <a>EventSequence</a> in a <a>Gesture</a>.
--   
--   <i>Since: 3.14</i>
data () => EventSequenceState

-- | The sequence is handled, but not grabbed.
EventSequenceStateNone :: EventSequenceState

-- | The sequence is handled and grabbed.
EventSequenceStateClaimed :: EventSequenceState

-- | The sequence is denied.
EventSequenceStateDenied :: EventSequenceState

-- | Catch-all for unknown values
AnotherEventSequenceState :: Int -> EventSequenceState

-- | Used to specify the style of the expanders drawn by a <a>TreeView</a>.
data () => ExpanderStyle

-- | The style used for a collapsed subtree.
ExpanderStyleCollapsed :: ExpanderStyle

-- | Intermediate style used during animation.
ExpanderStyleSemiCollapsed :: ExpanderStyle

-- | Intermediate style used during animation.
ExpanderStyleSemiExpanded :: ExpanderStyle

-- | The style used for an expanded subtree.
ExpanderStyleExpanded :: ExpanderStyle

-- | Catch-all for unknown values
AnotherExpanderStyle :: Int -> ExpanderStyle

-- | Describes whether a <a>FileChooser</a> is being used to open existing
--   files or to save to a possibly new file.
data () => FileChooserAction

-- | Indicates open mode. The file chooser will only let the user pick an
--   existing file.
FileChooserActionOpen :: FileChooserAction

-- | Indicates save mode. The file chooser will let the user pick an
--   existing file, or type in a new filename.
FileChooserActionSave :: FileChooserAction

-- | Indicates an Open mode for selecting folders. The file chooser will
--   let the user pick an existing folder.
FileChooserActionSelectFolder :: FileChooserAction

-- | Indicates a mode for creating a new folder. The file chooser will let
--   the user name an existing or new folder.
FileChooserActionCreateFolder :: FileChooserAction

-- | Catch-all for unknown values
AnotherFileChooserAction :: Int -> FileChooserAction

-- | These identify the various errors that can occur while calling
--   <a>FileChooser</a> functions.
data () => FileChooserError

-- | Indicates that a file does not exist.
FileChooserErrorNonexistent :: FileChooserError

-- | Indicates a malformed filename.
FileChooserErrorBadFilename :: FileChooserError

-- | Indicates a duplicate path (e.g. when adding a bookmark).
FileChooserErrorAlreadyExists :: FileChooserError

-- | Indicates an incomplete hostname (e.g. "http://foo" without a slash
--   after that).
FileChooserErrorIncompleteHostname :: FileChooserError

-- | Catch-all for unknown values
AnotherFileChooserError :: Int -> FileChooserError

-- | Style for input method preedit. See also
--   <a>Settings:gtkImPreeditStyle</a>
data () => IMPreeditStyle

-- | Deprecated
IMPreeditStyleNothing :: IMPreeditStyle

-- | Deprecated
IMPreeditStyleCallback :: IMPreeditStyle

-- | Deprecated
IMPreeditStyleNone :: IMPreeditStyle

-- | Catch-all for unknown values
AnotherIMPreeditStyle :: Int -> IMPreeditStyle

-- | Style for input method status. See also
--   <a>Settings:gtkImStatusStyle</a>
data () => IMStatusStyle

-- | Deprecated
IMStatusStyleNothing :: IMStatusStyle

-- | Deprecated
IMStatusStyleCallback :: IMStatusStyle

-- | Deprecated
IMStatusStyleNone :: IMStatusStyle

-- | Catch-all for unknown values
AnotherIMStatusStyle :: Int -> IMStatusStyle

-- | Error codes for GtkIconTheme operations.
data () => IconThemeError

-- | The icon specified does not exist in the theme
IconThemeErrorNotFound :: IconThemeError

-- | An unspecified error occurred.
IconThemeErrorFailed :: IconThemeError

-- | Catch-all for unknown values
AnotherIconThemeError :: Int -> IconThemeError

-- | An enum for determining where a dropped item goes.
data () => IconViewDropPosition

-- | no drop possible
IconViewDropPositionNoDrop :: IconViewDropPosition

-- | dropped item replaces the item
IconViewDropPositionDropInto :: IconViewDropPosition

-- | droppped item is inserted to the left
IconViewDropPositionDropLeft :: IconViewDropPosition

-- | dropped item is inserted to the right
IconViewDropPositionDropRight :: IconViewDropPosition

-- | dropped item is inserted above
IconViewDropPositionDropAbove :: IconViewDropPosition

-- | dropped item is inserted below
IconViewDropPositionDropBelow :: IconViewDropPosition

-- | Catch-all for unknown values
AnotherIconViewDropPosition :: Int -> IconViewDropPosition

-- | Describes the image data representation used by a <a>Image</a>. If you
--   want to get the image from the widget, you can only get the
--   currently-stored representation. e.g. if the
--   <a>imageGetStorageType</a> returns <tt><i>GTK_IMAGE_PIXBUF</i></tt>,
--   then you can call <a>imageGetPixbuf</a> but not <a>imageGetStock</a>.
--   For empty images, you can request any storage type (call any of the
--   "get" functions), but they will all return <a>Nothing</a> values.
data () => ImageType

-- | there is no image displayed by the widget
ImageTypeEmpty :: ImageType

-- | the widget contains a <a>Pixbuf</a>
ImageTypePixbuf :: ImageType

-- | the widget contains a [stock item name][gtkstock]
ImageTypeStock :: ImageType

-- | the widget contains a <a>IconSet</a>
ImageTypeIconSet :: ImageType

-- | the widget contains a <a>PixbufAnimation</a>
ImageTypeAnimation :: ImageType

-- | the widget contains a named icon. This image type was added in GTK+
--   2.6
ImageTypeIconName :: ImageType

-- | the widget contains a <a>Icon</a>. This image type was added in GTK+
--   2.14
ImageTypeGicon :: ImageType

-- | the widget contains a <a>Surface</a>. This image type was added in
--   GTK+ 3.10
ImageTypeSurface :: ImageType

-- | Catch-all for unknown values
AnotherImageType :: Int -> ImageType

-- | An enumeration representing directional movements within a menu.
data () => MenuDirectionType

-- | To the parent menu shell
MenuDirectionTypeParent :: MenuDirectionType

-- | To the submenu, if any, associated with the item
MenuDirectionTypeChild :: MenuDirectionType

-- | To the next menu item
MenuDirectionTypeNext :: MenuDirectionType

-- | To the previous menu item
MenuDirectionTypePrev :: MenuDirectionType

-- | Catch-all for unknown values
AnotherMenuDirectionType :: Int -> MenuDirectionType

-- | <i>No description available in the introspection data.</i>
data () => NotebookTab

-- | <i>No description available in the introspection data.</i>
NotebookTabFirst :: NotebookTab

-- | <i>No description available in the introspection data.</i>
NotebookTabLast :: NotebookTab

-- | Catch-all for unknown values
AnotherNotebookTab :: Int -> NotebookTab

-- | Represents the packing location <a>Box</a> children. (See:
--   <a>VBox</a>, <a>HBox</a>, and <a>ButtonBox</a>).
data () => PackType

-- | The child is packed into the start of the box
PackTypeStart :: PackType

-- | The child is packed into the end of the box
PackTypeEnd :: PackType

-- | Catch-all for unknown values
AnotherPackType :: Int -> PackType

-- | The type of a pad action.
data () => PadActionType

-- | Action is triggered by a pad button
PadActionTypeButton :: PadActionType

-- | Action is triggered by a pad ring
PadActionTypeRing :: PadActionType

-- | Action is triggered by a pad strip
PadActionTypeStrip :: PadActionType

-- | Catch-all for unknown values
AnotherPadActionType :: Int -> PadActionType

-- | Describes the panning direction of a <a>GesturePan</a>
--   
--   <i>Since: 3.14</i>
data () => PanDirection

-- | panned towards the left
PanDirectionLeft :: PanDirection

-- | panned towards the right
PanDirectionRight :: PanDirection

-- | panned upwards
PanDirectionUp :: PanDirection

-- | panned downwards
PanDirectionDown :: PanDirection

-- | Catch-all for unknown values
AnotherPanDirection :: Int -> PanDirection

-- | Widget path types. See also <a>bindingSetAddPath</a>.
data () => PathType

-- | Deprecated
PathTypeWidget :: PathType

-- | Deprecated
PathTypeWidgetClass :: PathType

-- | Deprecated
PathTypeClass :: PathType

-- | Catch-all for unknown values
AnotherPathType :: Int -> PathType

-- | Describes constraints to positioning of popovers. More values may be
--   added to this enumeration in the future.
--   
--   <i>Since: 3.20</i>
data () => PopoverConstraint

-- | Don't constrain the popover position beyond what is imposed by the
--   implementation
PopoverConstraintNone :: PopoverConstraint

-- | Constrain the popover to the boundaries of the window that it is
--   attached to
PopoverConstraintWindow :: PopoverConstraint

-- | Catch-all for unknown values
AnotherPopoverConstraint :: Int -> PopoverConstraint

-- | Describes which edge of a widget a certain feature is positioned at,
--   e.g. the tabs of a <a>Notebook</a>, the handle of a <a>HandleBox</a>
--   or the label of a <a>Scale</a>.
data () => PositionType

-- | The feature is at the left edge.
PositionTypeLeft :: PositionType

-- | The feature is at the right edge.
PositionTypeRight :: PositionType

-- | The feature is at the top edge.
PositionTypeTop :: PositionType

-- | The feature is at the bottom edge.
PositionTypeBottom :: PositionType

-- | Catch-all for unknown values
AnotherPositionType :: Int -> PositionType

-- | Error codes that identify various errors that can occur while using
--   the GTK+ printing support.
data () => PrintError

-- | An unspecified error occurred.
PrintErrorGeneral :: PrintError

-- | An internal error occurred.
PrintErrorInternalError :: PrintError

-- | A memory allocation failed.
PrintErrorNomem :: PrintError

-- | An error occurred while loading a page setup or paper size from a key
--   file.
PrintErrorInvalidFile :: PrintError

-- | Catch-all for unknown values
AnotherPrintError :: Int -> PrintError

-- | The <i><tt>action</tt></i> parameter to <a>printOperationRun</a>
--   determines what action the print operation should perform.
data () => PrintOperationAction

-- | Show the print dialog.
PrintOperationActionPrintDialog :: PrintOperationAction

-- | Start to print without showing the print dialog, based on the current
--   print settings.
PrintOperationActionPrint :: PrintOperationAction

-- | Show the print preview.
PrintOperationActionPreview :: PrintOperationAction

-- | Export to a file. This requires the export-filename property to be
--   set.
PrintOperationActionExport :: PrintOperationAction

-- | Catch-all for unknown values
AnotherPrintOperationAction :: Int -> PrintOperationAction

-- | A value of this type is returned by <a>printOperationRun</a>.
data () => PrintOperationResult

-- | An error has occurred.
PrintOperationResultError :: PrintOperationResult

-- | The print settings should be stored.
PrintOperationResultApply :: PrintOperationResult

-- | The print operation has been canceled, the print settings should not
--   be stored.
PrintOperationResultCancel :: PrintOperationResult

-- | The print operation is not complete yet. This value will only be
--   returned when running asynchronously.
PrintOperationResultInProgress :: PrintOperationResult

-- | Catch-all for unknown values
AnotherPrintOperationResult :: Int -> PrintOperationResult

-- | Describes the stage at which events are fed into a
--   <a>EventController</a>.
--   
--   <i>Since: 3.14</i>
data () => PropagationPhase

-- | Events are not delivered automatically. Those can be manually fed
--   through <a>eventControllerHandleEvent</a>. This should only be used
--   when full control about when, or whether the controller handles the
--   event is needed.
PropagationPhaseNone :: PropagationPhase

-- | Events are delivered in the capture phase. The capture phase happens
--   before the bubble phase, runs from the toplevel down to the event
--   widget. This option should only be used on containers that might
--   possibly handle events before their children do.
PropagationPhaseCapture :: PropagationPhase

-- | Events are delivered in the bubble phase. The bubble phase happens
--   after the capture phase, and before the default handlers are run. This
--   phase runs from the event widget, up to the toplevel.
PropagationPhaseBubble :: PropagationPhase

-- | Events are delivered in the default widget event handlers, note that
--   widget implementations must chain up on button, motion, touch and grab
--   broken handlers for controllers in this phase to be run.
PropagationPhaseTarget :: PropagationPhase

-- | Catch-all for unknown values
AnotherPropagationPhase :: Int -> PropagationPhase

-- | The <a>RcTokenType</a> enumeration represents the tokens in the RC
--   file. It is exposed so that theme engines can reuse these tokens when
--   parsing the theme-engine specific portions of a RC file.
data () => RcTokenType

-- | Deprecated
RcTokenTypeInvalid :: RcTokenType

-- | Deprecated
RcTokenTypeInclude :: RcTokenType

-- | Deprecated
RcTokenTypeNormal :: RcTokenType

-- | Deprecated
RcTokenTypeActive :: RcTokenType

-- | Deprecated
RcTokenTypePrelight :: RcTokenType

-- | Deprecated
RcTokenTypeSelected :: RcTokenType

-- | Deprecated
RcTokenTypeInsensitive :: RcTokenType

-- | Deprecated
RcTokenTypeFg :: RcTokenType

-- | Deprecated
RcTokenTypeBg :: RcTokenType

-- | Deprecated
RcTokenTypeText :: RcTokenType

-- | Deprecated
RcTokenTypeBase :: RcTokenType

-- | Deprecated
RcTokenTypeXthickness :: RcTokenType

-- | Deprecated
RcTokenTypeYthickness :: RcTokenType

-- | Deprecated
RcTokenTypeFont :: RcTokenType

-- | Deprecated
RcTokenTypeFontset :: RcTokenType

-- | Deprecated
RcTokenTypeFontName :: RcTokenType

-- | Deprecated
RcTokenTypeBgPixmap :: RcTokenType

-- | Deprecated
RcTokenTypePixmapPath :: RcTokenType

-- | Deprecated
RcTokenTypeStyle :: RcTokenType

-- | Deprecated
RcTokenTypeBinding :: RcTokenType

-- | Deprecated
RcTokenTypeBind :: RcTokenType

-- | Deprecated
RcTokenTypeWidget :: RcTokenType

-- | Deprecated
RcTokenTypeWidgetClass :: RcTokenType

-- | Deprecated
RcTokenTypeClass :: RcTokenType

-- | Deprecated
RcTokenTypeLowest :: RcTokenType

-- | Deprecated
RcTokenTypeGtk :: RcTokenType

-- | Deprecated
RcTokenTypeApplication :: RcTokenType

-- | Deprecated
RcTokenTypeTheme :: RcTokenType

-- | Deprecated
RcTokenTypeRc :: RcTokenType

-- | Deprecated
RcTokenTypeHighest :: RcTokenType

-- | Deprecated
RcTokenTypeEngine :: RcTokenType

-- | Deprecated
RcTokenTypeModulePath :: RcTokenType

-- | Deprecated
RcTokenTypeImModulePath :: RcTokenType

-- | Deprecated
RcTokenTypeImModuleFile :: RcTokenType

-- | Deprecated
RcTokenTypeStock :: RcTokenType

-- | Deprecated
RcTokenTypeLtr :: RcTokenType

-- | Deprecated
RcTokenTypeRtl :: RcTokenType

-- | Deprecated
RcTokenTypeColor :: RcTokenType

-- | Deprecated
RcTokenTypeUnbind :: RcTokenType

-- | Deprecated
RcTokenTypeLast :: RcTokenType

-- | Catch-all for unknown values
AnotherRcTokenType :: Int -> RcTokenType

-- | These identify the various errors that can occur while calling
--   <a>RecentChooser</a> functions.
--   
--   <i>Since: 2.10</i>
data () => RecentChooserError

-- | Indicates that a file does not exist
RecentChooserErrorNotFound :: RecentChooserError

-- | Indicates a malformed URI
RecentChooserErrorInvalidUri :: RecentChooserError

-- | Catch-all for unknown values
AnotherRecentChooserError :: Int -> RecentChooserError

-- | Error codes for <a>RecentManager</a> operations
--   
--   <i>Since: 2.10</i>
data () => RecentManagerError

-- | the URI specified does not exists in the recently used resources list.
RecentManagerErrorNotFound :: RecentManagerError

-- | the URI specified is not valid.
RecentManagerErrorInvalidUri :: RecentManagerError

-- | the supplied string is not UTF-8 encoded.
RecentManagerErrorInvalidEncoding :: RecentManagerError

-- | no application has registered the specified item.
RecentManagerErrorNotRegistered :: RecentManagerError

-- | failure while reading the recently used resources file.
RecentManagerErrorRead :: RecentManagerError

-- | failure while writing the recently used resources file.
RecentManagerErrorWrite :: RecentManagerError

-- | unspecified error.
RecentManagerErrorUnknown :: RecentManagerError

-- | Catch-all for unknown values
AnotherRecentManagerError :: Int -> RecentManagerError

-- | Used to specify the sorting method to be applyed to the recently used
--   resource list.
--   
--   <i>Since: 2.10</i>
data () => RecentSortType

-- | Do not sort the returned list of recently used resources.
RecentSortTypeNone :: RecentSortType

-- | Sort the returned list with the most recently used items first.
RecentSortTypeMru :: RecentSortType

-- | Sort the returned list with the least recently used items first.
RecentSortTypeLru :: RecentSortType

-- | Sort the returned list using a custom sorting function passed using
--   <a>recentChooserSetSortFunc</a>.
RecentSortTypeCustom :: RecentSortType

-- | Catch-all for unknown values
AnotherRecentSortType :: Int -> RecentSortType

-- | <i>No description available in the introspection data.</i>
data () => ResizeMode

-- | Pass resize request to the parent
ResizeModeParent :: ResizeMode

-- | Queue resizes on this widget
ResizeModeQueue :: ResizeMode

-- | Resize immediately. Deprecated.
ResizeModeImmediate :: ResizeMode

-- | Catch-all for unknown values
AnotherResizeMode :: Int -> ResizeMode

-- | Predefined values for use as response ids in <a>dialogAddButton</a>.
--   All predefined values are negative; GTK+ leaves values of 0 or greater
--   for application-defined response ids.
data () => ResponseType

-- | Returned if an action widget has no response id, or if the dialog gets
--   programmatically hidden or destroyed
ResponseTypeNone :: ResponseType

-- | Generic response id, not used by GTK+ dialogs
ResponseTypeReject :: ResponseType

-- | Generic response id, not used by GTK+ dialogs
ResponseTypeAccept :: ResponseType

-- | Returned if the dialog is deleted
ResponseTypeDeleteEvent :: ResponseType

-- | Returned by OK buttons in GTK+ dialogs
ResponseTypeOk :: ResponseType

-- | Returned by Cancel buttons in GTK+ dialogs
ResponseTypeCancel :: ResponseType

-- | Returned by Close buttons in GTK+ dialogs
ResponseTypeClose :: ResponseType

-- | Returned by Yes buttons in GTK+ dialogs
ResponseTypeYes :: ResponseType

-- | Returned by No buttons in GTK+ dialogs
ResponseTypeNo :: ResponseType

-- | Returned by Apply buttons in GTK+ dialogs
ResponseTypeApply :: ResponseType

-- | Returned by Help buttons in GTK+ dialogs
ResponseTypeHelp :: ResponseType

-- | Catch-all for unknown values
AnotherResponseType :: Int -> ResponseType

-- | These enumeration values describe the possible transitions when the
--   child of a <a>Revealer</a> widget is shown or hidden.
data () => RevealerTransitionType

-- | No transition
RevealerTransitionTypeNone :: RevealerTransitionType

-- | Fade in
RevealerTransitionTypeCrossfade :: RevealerTransitionType

-- | Slide in from the left
RevealerTransitionTypeSlideRight :: RevealerTransitionType

-- | Slide in from the right
RevealerTransitionTypeSlideLeft :: RevealerTransitionType

-- | Slide in from the bottom
RevealerTransitionTypeSlideUp :: RevealerTransitionType

-- | Slide in from the top
RevealerTransitionTypeSlideDown :: RevealerTransitionType

-- | Catch-all for unknown values
AnotherRevealerTransitionType :: Int -> RevealerTransitionType

-- | Determines how GTK+ handles the sensitivity of stepper arrows at the
--   end of range widgets.
data () => SensitivityType

-- | The arrow is made insensitive if the thumb is at the end
SensitivityTypeAuto :: SensitivityType

-- | The arrow is always sensitive
SensitivityTypeOn :: SensitivityType

-- | The arrow is always insensitive
SensitivityTypeOff :: SensitivityType

-- | Catch-all for unknown values
AnotherSensitivityType :: Int -> SensitivityType

-- | GtkShortcutType specifies the kind of shortcut that is being
--   described. More values may be added to this enumeration over time.
--   
--   <i>Since: 3.20</i>
data () => ShortcutType

-- | The shortcut is a keyboard accelerator. The
--   <a>ShortcutsShortcut:accelerator</a> property will be used.
ShortcutTypeAccelerator :: ShortcutType

-- | The shortcut is a pinch gesture. GTK+ provides an icon and subtitle.
ShortcutTypeGesturePinch :: ShortcutType

-- | The shortcut is a stretch gesture. GTK+ provides an icon and subtitle.
ShortcutTypeGestureStretch :: ShortcutType

-- | The shortcut is a clockwise rotation gesture. GTK+ provides an icon
--   and subtitle.
ShortcutTypeGestureRotateClockwise :: ShortcutType

-- | The shortcut is a counterclockwise rotation gesture. GTK+ provides an
--   icon and subtitle.
ShortcutTypeGestureRotateCounterclockwise :: ShortcutType

-- | The shortcut is a two-finger swipe gesture. GTK+ provides an icon and
--   subtitle.
ShortcutTypeGestureTwoFingerSwipeLeft :: ShortcutType

-- | The shortcut is a two-finger swipe gesture. GTK+ provides an icon and
--   subtitle.
ShortcutTypeGestureTwoFingerSwipeRight :: ShortcutType

-- | The shortcut is a gesture. The <a>ShortcutsShortcut:icon</a> property
--   will be used.
ShortcutTypeGesture :: ShortcutType

-- | Catch-all for unknown values
AnotherShortcutType :: Int -> ShortcutType

-- | Determines the direction of a sort.
data () => SortType

-- | Sorting is in ascending order.
SortTypeAscending :: SortType

-- | Sorting is in descending order.
SortTypeDescending :: SortType

-- | Catch-all for unknown values
AnotherSortType :: Int -> SortType

-- | These enumeration values describe the possible transitions between
--   pages in a <a>Stack</a> widget.
--   
--   New values may be added to this enumeration over time.
data () => StackTransitionType

-- | No transition
StackTransitionTypeNone :: StackTransitionType

-- | A cross-fade
StackTransitionTypeCrossfade :: StackTransitionType

-- | Slide from left to right
StackTransitionTypeSlideRight :: StackTransitionType

-- | Slide from right to left
StackTransitionTypeSlideLeft :: StackTransitionType

-- | Slide from bottom up
StackTransitionTypeSlideUp :: StackTransitionType

-- | Slide from top down
StackTransitionTypeSlideDown :: StackTransitionType

-- | Slide from left or right according to the children order
StackTransitionTypeSlideLeftRight :: StackTransitionType

-- | Slide from top down or bottom up according to the order
StackTransitionTypeSlideUpDown :: StackTransitionType

-- | Cover the old page by sliding up. Since 3.12
StackTransitionTypeOverUp :: StackTransitionType

-- | Cover the old page by sliding down. Since: 3.12
StackTransitionTypeOverDown :: StackTransitionType

-- | Cover the old page by sliding to the left. Since: 3.12
StackTransitionTypeOverLeft :: StackTransitionType

-- | Cover the old page by sliding to the right. Since: 3.12
StackTransitionTypeOverRight :: StackTransitionType

-- | Uncover the new page by sliding up. Since 3.12
StackTransitionTypeUnderUp :: StackTransitionType

-- | Uncover the new page by sliding down. Since: 3.12
StackTransitionTypeUnderDown :: StackTransitionType

-- | Uncover the new page by sliding to the left. Since: 3.12
StackTransitionTypeUnderLeft :: StackTransitionType

-- | Uncover the new page by sliding to the right. Since: 3.12
StackTransitionTypeUnderRight :: StackTransitionType

-- | Cover the old page sliding up or uncover the new page sliding down,
--   according to order. Since: 3.12
StackTransitionTypeOverUpDown :: StackTransitionType

-- | Cover the old page sliding down or uncover the new page sliding up,
--   according to order. Since: 3.14
StackTransitionTypeOverDownUp :: StackTransitionType

-- | Cover the old page sliding left or uncover the new page sliding right,
--   according to order. Since: 3.14
StackTransitionTypeOverLeftRight :: StackTransitionType

-- | Cover the old page sliding right or uncover the new page sliding left,
--   according to order. Since: 3.14
StackTransitionTypeOverRightLeft :: StackTransitionType

-- | Catch-all for unknown values
AnotherStackTransitionType :: Int -> StackTransitionType

-- | Granularity types that extend the text selection. Use the
--   <a>TextView::extendSelection</a> signal to customize the selection.
--   
--   <i>Since: 3.16</i>
data () => TextExtendSelection

-- | Selects the current word. It is triggered by a double-click for
--   example.
TextExtendSelectionWord :: TextExtendSelection

-- | Selects the current line. It is triggered by a triple-click for
--   example.
TextExtendSelectionLine :: TextExtendSelection

-- | Catch-all for unknown values
AnotherTextExtendSelection :: Int -> TextExtendSelection

-- | Used to reference the layers of <a>TextView</a> for the purpose of
--   customized drawing with the <a>draw_layer</a> vfunc.
data () => TextViewLayer

-- | Old deprecated layer, use <a>TextViewLayerBelowText</a> instead
TextViewLayerBelow :: TextViewLayer

-- | Old deprecated layer, use <a>TextViewLayerAboveText</a> instead
TextViewLayerAbove :: TextViewLayer

-- | The layer rendered below the text (but above the background). Since:
--   3.20
TextViewLayerBelowText :: TextViewLayer

-- | The layer rendered above the text. Since: 3.20
TextViewLayerAboveText :: TextViewLayer

-- | Catch-all for unknown values
AnotherTextViewLayer :: Int -> TextViewLayer

-- | Whether spacers are vertical lines or just blank.
data () => ToolbarSpaceStyle

-- | Use blank spacers.
ToolbarSpaceStyleEmpty :: ToolbarSpaceStyle

-- | Use vertical lines for spacers.
ToolbarSpaceStyleLine :: ToolbarSpaceStyle

-- | Catch-all for unknown values
AnotherToolbarSpaceStyle :: Int -> ToolbarSpaceStyle

-- | An enum for determining where a dropped row goes.
data () => TreeViewDropPosition

-- | dropped row is inserted before
TreeViewDropPositionBefore :: TreeViewDropPosition

-- | dropped row is inserted after
TreeViewDropPositionAfter :: TreeViewDropPosition

-- | dropped row becomes a child or is inserted before
TreeViewDropPositionIntoOrBefore :: TreeViewDropPosition

-- | dropped row becomes a child or is inserted after
TreeViewDropPositionIntoOrAfter :: TreeViewDropPosition

-- | Catch-all for unknown values
AnotherTreeViewDropPosition :: Int -> TreeViewDropPosition

-- | See also <a>printSettingsSetPaperWidth</a>.
data () => Unit

-- | No units.
UnitNone :: Unit

-- | Dimensions in points.
UnitPoints :: Unit

-- | Dimensions in inches.
UnitInch :: Unit

-- | Dimensions in millimeters
UnitMm :: Unit

-- | Catch-all for unknown values
AnotherUnit :: Int -> Unit

-- | Kinds of widget-specific help. Used by the <a>showHelp</a> signal.
data () => WidgetHelpType

-- | Tooltip.
WidgetHelpTypeTooltip :: WidgetHelpType

-- | What’s this.
WidgetHelpTypeWhatsThis :: WidgetHelpType

-- | Catch-all for unknown values
AnotherWidgetHelpType :: Int -> WidgetHelpType

-- | Window placement can be influenced using this enumeration. Note that
--   using <tt><i>GTK_WIN_POS_CENTER_ALWAYS</i></tt> is almost always a bad
--   idea. It won’t necessarily work well with all window managers or on
--   all windowing systems.
data () => WindowPosition

-- | No influence is made on placement.
WindowPositionNone :: WindowPosition

-- | Windows should be placed in the center of the screen.
WindowPositionCenter :: WindowPosition

-- | Windows should be placed at the current mouse position.
WindowPositionMouse :: WindowPosition

-- | Keep window centered as it changes size, etc.
WindowPositionCenterAlways :: WindowPosition

-- | Center the window on its transient parent (see
--   <a>windowSetTransientFor</a>).
WindowPositionCenterOnParent :: WindowPosition

-- | Catch-all for unknown values
AnotherWindowPosition :: Int -> WindowPosition

-- | Accelerator flags used with <a>accelGroupConnect</a>.
data () => AccelFlags

-- | Accelerator is visible
AccelFlagsVisible :: AccelFlags

-- | Accelerator not removable
AccelFlagsLocked :: AccelFlags

-- | Mask
AccelFlagsMask :: AccelFlags

-- | Catch-all for unknown values
AnotherAccelFlags :: Int -> AccelFlags

-- | Types of user actions that may be blocked by
--   <a>applicationInhibit</a>.
--   
--   <i>Since: 3.4</i>
data () => ApplicationInhibitFlags

-- | Inhibit ending the user session by logging out or by shutting down the
--   computer
ApplicationInhibitFlagsLogout :: ApplicationInhibitFlags

-- | Inhibit user switching
ApplicationInhibitFlagsSwitch :: ApplicationInhibitFlags

-- | Inhibit suspending the session or computer
ApplicationInhibitFlagsSuspend :: ApplicationInhibitFlags

-- | Inhibit the session being marked as idle (and possibly locked)
ApplicationInhibitFlagsIdle :: ApplicationInhibitFlags

-- | Catch-all for unknown values
AnotherApplicationInhibitFlags :: Int -> ApplicationInhibitFlags

-- | These options can be used to influence the display and behaviour of a
--   <a>Calendar</a>.
data () => CalendarDisplayOptions

-- | Specifies that the month and year should be displayed.
CalendarDisplayOptionsShowHeading :: CalendarDisplayOptions

-- | Specifies that three letter day descriptions should be present.
CalendarDisplayOptionsShowDayNames :: CalendarDisplayOptions

-- | Prevents the user from switching months with the calendar.
CalendarDisplayOptionsNoMonthChange :: CalendarDisplayOptions

-- | Displays each week numbers of the current year, down the left side of
--   the calendar.
CalendarDisplayOptionsShowWeekNumbers :: CalendarDisplayOptions

-- | Just show an indicator, not the full details text when details are
--   provided. See <a>calendarSetDetailFunc</a>.
CalendarDisplayOptionsShowDetails :: CalendarDisplayOptions

-- | Catch-all for unknown values
AnotherCalendarDisplayOptions :: Int -> CalendarDisplayOptions

-- | <i>No description available in the introspection data.</i>
data () => DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagMisc :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagPlugsocket :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagText :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagTree :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagUpdates :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagKeybindings :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagMultihead :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagModules :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagGeometry :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagIcontheme :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagPrinting :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagBuilder :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagSizeRequest :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagNoCssCache :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagBaselines :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagPixelCache :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagNoPixelCache :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagInteractive :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagTouchscreen :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagActions :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagResize :: DebugFlag

-- | <i>No description available in the introspection data.</i>
DebugFlagLayout :: DebugFlag

-- | Catch-all for unknown values
AnotherDebugFlag :: Int -> DebugFlag

-- | The <a>DestDefaults</a> enumeration specifies the various types of
--   action that will be taken on behalf of the user for a drag destination
--   site.
data () => DestDefaults

-- | If set for a widget, GTK+, during a drag over this widget will check
--   if the drag matches this widget’s list of possible targets and
--   actions. GTK+ will then call <a>dragStatus</a> as appropriate.
DestDefaultsMotion :: DestDefaults

-- | If set for a widget, GTK+ will draw a highlight on this widget as long
--   as a drag is over this widget and the widget drag format and action
--   are acceptable.
DestDefaultsHighlight :: DestDefaults

-- | If set for a widget, when a drop occurs, GTK+ will will check if the
--   drag matches this widget’s list of possible targets and actions. If
--   so, GTK+ will call <a>widgetDragGetData</a> on behalf of the widget.
--   Whether or not the drop is successful, GTK+ will call
--   <a>dragFinish</a>. If the action was a move, then if the drag was
--   successful, then <a>True</a> will be passed for the
--   <i><tt>delete</tt></i> parameter to <a>dragFinish</a>.
DestDefaultsDrop :: DestDefaults

-- | If set, specifies that all default actions should be taken.
DestDefaultsAll :: DestDefaults

-- | Catch-all for unknown values
AnotherDestDefaults :: Int -> DestDefaults

-- | Flags used to influence dialog construction.
data () => DialogFlags

-- | Make the constructed dialog modal, see <a>windowSetModal</a>
DialogFlagsModal :: DialogFlags

-- | Destroy the dialog when its parent is destroyed, see
--   <a>windowSetDestroyWithParent</a>
DialogFlagsDestroyWithParent :: DialogFlags

-- | Create dialog with actions in header bar instead of action area. Since
--   3.12.
DialogFlagsUseHeaderBar :: DialogFlags

-- | Catch-all for unknown values
AnotherDialogFlags :: Int -> DialogFlags

-- | Describes the behavior of a <a>EventControllerScroll</a>.
--   
--   <i>Since: 3.24</i>
data () => EventControllerScrollFlags

-- | Don't emit scroll.
EventControllerScrollFlagsNone :: EventControllerScrollFlags

-- | Emit scroll with vertical deltas.
EventControllerScrollFlagsVertical :: EventControllerScrollFlags

-- | Emit scroll with horizontal deltas.
EventControllerScrollFlagsHorizontal :: EventControllerScrollFlags

-- | Only emit deltas that are multiples of 1.
EventControllerScrollFlagsDiscrete :: EventControllerScrollFlags

-- | Emit <a>EventControllerScroll::decelerate</a> after continuous scroll
--   finishes.
EventControllerScrollFlagsKinetic :: EventControllerScrollFlags

-- | Emit scroll on both axes.
EventControllerScrollFlagsBothAxes :: EventControllerScrollFlags

-- | Catch-all for unknown values
AnotherEventControllerScrollFlags :: Int -> EventControllerScrollFlags

-- | These flags indicate what parts of a <a>FileFilterInfo</a> struct are
--   filled or need to be filled.
data () => FileFilterFlags

-- | the filename of the file being tested
FileFilterFlagsFilename :: FileFilterFlags

-- | the URI for the file being tested
FileFilterFlagsUri :: FileFilterFlags

-- | the string that will be used to display the file in the file chooser
FileFilterFlagsDisplayName :: FileFilterFlags

-- | the mime type of the file
FileFilterFlagsMimeType :: FileFilterFlags

-- | Catch-all for unknown values
AnotherFileFilterFlags :: Int -> FileFilterFlags

-- | This enumeration specifies the granularity of font selection that is
--   desired in a font chooser.
--   
--   This enumeration may be extended in the future; applications should
--   ignore unknown values.
data () => FontChooserLevel

-- | Allow selecting a font family
FontChooserLevelFamily :: FontChooserLevel

-- | Allow selecting a specific font face
FontChooserLevelStyle :: FontChooserLevel

-- | Allow selecting a specific font size
FontChooserLevelSize :: FontChooserLevel

-- | <i>No description available in the introspection data.</i>
FontChooserLevelVariations :: FontChooserLevel

-- | Allow selecting specific OpenType font features
FontChooserLevelFeatures :: FontChooserLevel

-- | Catch-all for unknown values
AnotherFontChooserLevel :: Int -> FontChooserLevel

-- | Used to specify options for <a>iconThemeLookupIcon</a>
data () => IconLookupFlags

-- | Never get SVG icons, even if gdk-pixbuf supports them. Cannot be used
--   together with <a>IconLookupFlagsForceSvg</a>.
IconLookupFlagsNoSvg :: IconLookupFlags

-- | Get SVG icons, even if gdk-pixbuf doesn’t support them. Cannot be used
--   together with <a>IconLookupFlagsNoSvg</a>.
IconLookupFlagsForceSvg :: IconLookupFlags

-- | When passed to <a>iconThemeLookupIcon</a> includes builtin icons as
--   well as files. For a builtin icon, <a>iconInfoGetFilename</a> is
--   <a>Nothing</a> and you need to call <a>iconInfoGetBuiltinPixbuf</a>.
IconLookupFlagsUseBuiltin :: IconLookupFlags

-- | Try to shorten icon name at '-' characters before looking at inherited
--   themes. This flag is only supported in functions that take a single
--   icon name. For more general fallback, see <a>iconThemeChooseIcon</a>.
--   Since 2.12.
IconLookupFlagsGenericFallback :: IconLookupFlags

-- | Always get the icon scaled to the requested size. Since 2.14.
IconLookupFlagsForceSize :: IconLookupFlags

-- | Try to always load regular icons, even when symbolic icon names are
--   given. Since 3.14.
IconLookupFlagsForceRegular :: IconLookupFlags

-- | Try to always load symbolic icons, even when regular icon names are
--   given. Since 3.14.
IconLookupFlagsForceSymbolic :: IconLookupFlags

-- | Try to load a variant of the icon for left-to-right text direction.
--   Since 3.14.
IconLookupFlagsDirLtr :: IconLookupFlags

-- | Try to load a variant of the icon for right-to-left text direction.
--   Since 3.14.
IconLookupFlagsDirRtl :: IconLookupFlags

-- | Catch-all for unknown values
AnotherIconLookupFlags :: Int -> IconLookupFlags

-- | Describes hints that might be taken into account by input methods or
--   applications. Note that input methods may already tailor their
--   behaviour according to the <a>InputPurpose</a> of the entry.
--   
--   Some common sense is expected when using these flags - mixing
--   <i><tt>gTKINPUTHINTLOWERCASE</tt></i> with any of the uppercase hints
--   makes no sense.
--   
--   This enumeration may be extended in the future; input methods should
--   ignore unknown values.
--   
--   <i>Since: 3.6</i>
data () => InputHints

-- | No special behaviour suggested
InputHintsNone :: InputHints

-- | Suggest checking for typos
InputHintsSpellcheck :: InputHints

-- | Suggest not checking for typos
InputHintsNoSpellcheck :: InputHints

-- | Suggest word completion
InputHintsWordCompletion :: InputHints

-- | Suggest to convert all text to lowercase
InputHintsLowercase :: InputHints

-- | Suggest to capitalize all text
InputHintsUppercaseChars :: InputHints

-- | Suggest to capitalize the first character of each word
InputHintsUppercaseWords :: InputHints

-- | Suggest to capitalize the first word of each sentence
InputHintsUppercaseSentences :: InputHints

-- | Suggest to not show an onscreen keyboard (e.g for a calculator that
--   already has all the keys).
InputHintsInhibitOsk :: InputHints

-- | The text is vertical. Since 3.18
InputHintsVerticalWriting :: InputHints

-- | Suggest offering Emoji support. Since 3.22.20
InputHintsEmoji :: InputHints

-- | Suggest not offering Emoji support. Since 3.22.20
InputHintsNoEmoji :: InputHints

-- | Catch-all for unknown values
AnotherInputHints :: Int -> InputHints

-- | Describes how a rendered element connects to adjacent elements.
data () => JunctionSides

-- | No junctions.
JunctionSidesNone :: JunctionSides

-- | Element connects on the top-left corner.
JunctionSidesCornerTopleft :: JunctionSides

-- | Element connects on the top-right corner.
JunctionSidesCornerTopright :: JunctionSides

-- | Element connects on the bottom-left corner.
JunctionSidesCornerBottomleft :: JunctionSides

-- | Element connects on the bottom-right corner.
JunctionSidesCornerBottomright :: JunctionSides

-- | Element connects on the top side.
JunctionSidesTop :: JunctionSides

-- | Element connects on the bottom side.
JunctionSidesBottom :: JunctionSides

-- | Element connects on the left side.
JunctionSidesLeft :: JunctionSides

-- | Element connects on the right side.
JunctionSidesRight :: JunctionSides

-- | Catch-all for unknown values
AnotherJunctionSides :: Int -> JunctionSides

-- | Deprecated
data () => RcFlags

-- | Deprecated
RcFlagsFg :: RcFlags

-- | Deprecated
RcFlagsBg :: RcFlags

-- | Deprecated
RcFlagsText :: RcFlags

-- | Deprecated
RcFlagsBase :: RcFlags

-- | Catch-all for unknown values
AnotherRcFlags :: Int -> RcFlags

-- | These flags indicate what parts of a <a>RecentFilterInfo</a> struct
--   are filled or need to be filled.
data () => RecentFilterFlags

-- | the URI of the file being tested
RecentFilterFlagsUri :: RecentFilterFlags

-- | the string that will be used to display the file in the recent chooser
RecentFilterFlagsDisplayName :: RecentFilterFlags

-- | the mime type of the file
RecentFilterFlagsMimeType :: RecentFilterFlags

-- | the list of applications that have registered the file
RecentFilterFlagsApplication :: RecentFilterFlags

-- | the groups to which the file belongs to
RecentFilterFlagsGroup :: RecentFilterFlags

-- | the number of days elapsed since the file has been registered
RecentFilterFlagsAge :: RecentFilterFlags

-- | Catch-all for unknown values
AnotherRecentFilterFlags :: Int -> RecentFilterFlags

-- | Describes a region within a widget.
data () => RegionFlags

-- | Region has an even number within a set.
RegionFlagsEven :: RegionFlags

-- | Region has an odd number within a set.
RegionFlagsOdd :: RegionFlags

-- | Region is the first one within a set.
RegionFlagsFirst :: RegionFlags

-- | Region is the last one within a set.
RegionFlagsLast :: RegionFlags

-- | Region is the only one within a set.
RegionFlagsOnly :: RegionFlags

-- | Region is part of a sorted area.
RegionFlagsSorted :: RegionFlags

-- | Catch-all for unknown values
AnotherRegionFlags :: Int -> RegionFlags

-- | Flags that modify the behavior of <a>styleContextToString</a>. New
--   values may be added to this enumeration.
data () => StyleContextPrintFlags

-- | <i>No description available in the introspection data.</i>
StyleContextPrintFlagsNone :: StyleContextPrintFlags

-- | Print the entire tree of CSS nodes starting at the style context's
--   node
StyleContextPrintFlagsRecurse :: StyleContextPrintFlags

-- | Show the values of the CSS properties for each node
StyleContextPrintFlagsShowStyle :: StyleContextPrintFlags

-- | Catch-all for unknown values
AnotherStyleContextPrintFlags :: Int -> StyleContextPrintFlags

-- | Flags affecting how a search is done.
--   
--   If neither <tt><i>GTK_TEXT_SEARCH_VISIBLE_ONLY</i></tt> nor
--   <tt><i>GTK_TEXT_SEARCH_TEXT_ONLY</i></tt> are enabled, the match must
--   be exact; the special 0xFFFC character will match embedded pixbufs or
--   child widgets.
data () => TextSearchFlags

-- | Search only visible data. A search match may have invisible text
--   interspersed.
TextSearchFlagsVisibleOnly :: TextSearchFlags

-- | Search only text. A match may have pixbufs or child widgets mixed
--   inside the matched range.
TextSearchFlagsTextOnly :: TextSearchFlags

-- | The text will be matched regardless of what case it is in.
TextSearchFlagsCaseInsensitive :: TextSearchFlags

-- | Catch-all for unknown values
AnotherTextSearchFlags :: Int -> TextSearchFlags

-- | These enumeration values are used by <a>uIManagerAddUi</a> to
--   determine what UI element to create.
data () => UIManagerItemType

-- | Pick the type of the UI element according to context.
UIManagerItemTypeAuto :: UIManagerItemType

-- | Create a menubar.
UIManagerItemTypeMenubar :: UIManagerItemType

-- | Create a menu.
UIManagerItemTypeMenu :: UIManagerItemType

-- | Create a toolbar.
UIManagerItemTypeToolbar :: UIManagerItemType

-- | Insert a placeholder.
UIManagerItemTypePlaceholder :: UIManagerItemType

-- | Create a popup menu.
UIManagerItemTypePopup :: UIManagerItemType

-- | Create a menuitem.
UIManagerItemTypeMenuitem :: UIManagerItemType

-- | Create a toolitem.
UIManagerItemTypeToolitem :: UIManagerItemType

-- | Create a separator.
UIManagerItemTypeSeparator :: UIManagerItemType

-- | Install an accelerator.
UIManagerItemTypeAccelerator :: UIManagerItemType

-- | Same as <a>UIManagerItemTypePopup</a>, but the actions’ accelerators
--   are shown.
UIManagerItemTypePopupWithAccels :: UIManagerItemType

-- | Catch-all for unknown values
AnotherUIManagerItemType :: Int -> UIManagerItemType

-- | Type class for types which can be safely cast to <a>ColorChooser</a>,
--   for instance with <a>toColorChooser</a>.
class (GObject o, IsDescendantOf ColorChooser o) => IsColorChooser o

-- | Memory-managed wrapper type.
newtype () => ColorChooser
ColorChooser :: ManagedPtr ColorChooser -> ColorChooser

-- | Emitted when a color is activated from the color chooser. This usually
--   happens when the user clicks a color swatch, or a color is selected
--   and the user presses one of the keys Space, Shift+Space, Return or
--   Enter.
--   
--   <i>Since: 3.4</i>
type ColorChooserColorActivatedCallback = RGBA -> IO ()

-- | Type class for types which can be safely cast to <a>Editable</a>, for
--   instance with <a>toEditable</a>.
class (GObject o, IsDescendantOf Editable o) => IsEditable o

-- | Memory-managed wrapper type.
newtype () => Editable
Editable :: ManagedPtr Editable -> Editable

-- | This signal is emitted when text is inserted into the widget by the
--   user. The default handler for this signal will normally be responsible
--   for inserting the text, so by connecting to this signal and then
--   stopping the signal with <a>signalStopEmission</a>, it is possible to
--   modify the inserted text, or prevent it from being inserted entirely.
type EditableInsertTextCallback = Text -> Int32 -> Int32 -> IO Int32

-- | This signal is emitted when text is deleted from the widget by the
--   user. The default handler for this signal will normally be responsible
--   for deleting the text, so by connecting to this signal and then
--   stopping the signal with <a>signalStopEmission</a>, it is possible to
--   modify the range of deleted text, or prevent it from being deleted
--   entirely. The <i><tt>startPos</tt></i> and <i><tt>endPos</tt></i>
--   parameters are interpreted as for <a>editableDeleteText</a>.
type EditableDeleteTextCallback = Int32 -> Int32 -> IO ()

-- | The <a>changed</a> signal is emitted at the end of a single
--   user-visible operation on the contents of the <a>Editable</a>.
--   
--   E.g., a paste operation that replaces the contents of the selection
--   will cause only one signal emission (even though it is implemented by
--   first deleting the selection, then inserting the new content, and may
--   cause multiple <a>notify</a><a>text</a> signals to be emitted).
type EditableChangedCallback = IO ()

-- | Type class for types which can be safely cast to <a>Orientable</a>,
--   for instance with <a>toOrientable</a>.
class (GObject o, IsDescendantOf Orientable o) => IsOrientable o

-- | Memory-managed wrapper type.
newtype () => Orientable
Orientable :: ManagedPtr Orientable -> Orientable

-- | Type class for types which can be safely cast to <a>Adjustment</a>,
--   for instance with <a>toAdjustment</a>.
class (GObject o, IsDescendantOf Adjustment o) => IsAdjustment o

-- | Emitted when the <a>Adjustment:value</a> property has been changed.
type AdjustmentValueChangedCallback = IO ()

-- | Emitted when one or more of the <a>Adjustment</a> properties have been
--   changed, other than the <a>Adjustment:value</a> property.
type AdjustmentChangedCallback = IO ()

-- | Type class for types which can be safely cast to <a>EntryBuffer</a>,
--   for instance with <a>toEntryBuffer</a>.
class (GObject o, IsDescendantOf EntryBuffer o) => IsEntryBuffer o

-- | This signal is emitted after text is inserted into the buffer.
--   
--   <i>Since: 2.18</i>
type EntryBufferInsertedTextCallback = Word32 -> Text -> Word32 -> IO ()

-- | This signal is emitted after text is deleted from the buffer.
--   
--   <i>Since: 2.18</i>
type EntryBufferDeletedTextCallback = Word32 -> Word32 -> IO ()

-- | Type class for types which can be safely cast to
--   <a>EntryIconAccessible</a>, for instance with
--   <a>toEntryIconAccessible</a>.
class (GObject o, IsDescendantOf EntryIconAccessible o) => IsEntryIconAccessible o

-- | Memory-managed wrapper type.
newtype () => EntryIconAccessible
EntryIconAccessible :: ManagedPtr EntryIconAccessible -> EntryIconAccessible

-- | Type class for types which can be safely cast to <a>IMContext</a>, for
--   instance with <a>toIMContext</a>.
class (GObject o, IsDescendantOf IMContext o) => IsIMContext o

-- | Memory-managed wrapper type.
newtype () => IMContext
IMContext :: ManagedPtr IMContext -> IMContext

-- | The <a>retrieveSurrounding</a> signal is emitted when the input method
--   requires the context surrounding the cursor. The callback should set
--   the input method surrounding context by calling the
--   <a>iMContextSetSurrounding</a> method.
type IMContextRetrieveSurroundingCallback = IO Bool

-- | The <a>preeditStart</a> signal is emitted when a new preediting
--   sequence starts.
type IMContextPreeditStartCallback = IO ()

-- | The <a>preeditEnd</a> signal is emitted when a preediting sequence has
--   been completed or canceled.
type IMContextPreeditEndCallback = IO ()

-- | The <a>preeditChanged</a> signal is emitted whenever the preedit
--   sequence currently being entered has changed. It is also emitted at
--   the end of a preedit sequence, in which case
--   <a>iMContextGetPreeditString</a> returns the empty string.
type IMContextPreeditChangedCallback = IO ()

-- | The <a>deleteSurrounding</a> signal is emitted when the input method
--   needs to delete all or part of the context surrounding the cursor.
type IMContextDeleteSurroundingCallback = Int32 -> Int32 -> IO Bool

-- | The <a>commit</a> signal is emitted when a complete input sequence has
--   been entered by the user. This can be a single character immediately
--   after a key press or the final result of preediting.
type IMContextCommitCallback = Text -> IO ()

-- | Type class for types which can be safely cast to
--   <a>IMContextSimple</a>, for instance with <a>toIMContextSimple</a>.
class (GObject o, IsDescendantOf IMContextSimple o) => IsIMContextSimple o

-- | Memory-managed wrapper type.
newtype () => IMContextSimple
IMContextSimple :: ManagedPtr IMContextSimple -> IMContextSimple

-- | Type class for types which can be safely cast to <a>RcStyle</a>, for
--   instance with <a>toRcStyle</a>.
class (GObject o, IsDescendantOf RcStyle o) => IsRcStyle o

-- | Memory-managed wrapper type.
newtype () => BindingSignal
BindingSignal :: ManagedPtr BindingSignal -> BindingSignal

-- | Memory-managed wrapper type.
newtype () => BindingEntry
BindingEntry :: ManagedPtr BindingEntry -> BindingEntry

-- | Type class for types which can be safely cast to <a>Scrollable</a>,
--   for instance with <a>toScrollable</a>.
class (GObject o, IsDescendantOf Scrollable o) => IsScrollable o

-- | Memory-managed wrapper type.
newtype () => CssSection
CssSection :: ManagedPtr CssSection -> CssSection

-- | Memory-managed wrapper type.
newtype () => IMContextInfo
IMContextInfo :: ManagedPtr IMContextInfo -> IMContextInfo

-- | Memory-managed wrapper type.
newtype () => LabelSelectionInfo
LabelSelectionInfo :: ManagedPtr LabelSelectionInfo -> LabelSelectionInfo

-- | Memory-managed wrapper type.
newtype () => MountOperationHandlerIface_
MountOperationHandlerIface_ :: ManagedPtr MountOperationHandlerIface_ -> MountOperationHandlerIface_

-- | Memory-managed wrapper type.
newtype () => MountOperationHandlerProxyClass_
MountOperationHandlerProxyClass_ :: ManagedPtr MountOperationHandlerProxyClass_ -> MountOperationHandlerProxyClass_

-- | Memory-managed wrapper type.
newtype () => MountOperationHandlerProxy_
MountOperationHandlerProxy_ :: ManagedPtr MountOperationHandlerProxy_ -> MountOperationHandlerProxy_

-- | Memory-managed wrapper type.
newtype () => MountOperationHandlerSkeletonClass_
MountOperationHandlerSkeletonClass_ :: ManagedPtr MountOperationHandlerSkeletonClass_ -> MountOperationHandlerSkeletonClass_

-- | Memory-managed wrapper type.
newtype () => MountOperationHandlerSkeleton_
MountOperationHandlerSkeleton_ :: ManagedPtr MountOperationHandlerSkeleton_ -> MountOperationHandlerSkeleton_

-- | Memory-managed wrapper type.
newtype () => MountOperationHandler_
MountOperationHandler_ :: ManagedPtr MountOperationHandler_ -> MountOperationHandler_

-- | Memory-managed wrapper type.
newtype () => PageRange
PageRange :: ManagedPtr PageRange -> PageRange

-- | Type class for types which can be safely cast to <a>PageSetup</a>, for
--   instance with <a>toPageSetup</a>.
class (GObject o, IsDescendantOf PageSetup o) => IsPageSetup o

-- | Type class for types which can be safely cast to <a>PrintContext</a>,
--   for instance with <a>toPrintContext</a>.
class (GObject o, IsDescendantOf PrintContext o) => IsPrintContext o

-- | Type class for types which can be safely cast to
--   <a>PrintOperationPreview</a>, for instance with
--   <a>toPrintOperationPreview</a>.
class (GObject o, IsDescendantOf PrintOperationPreview o) => IsPrintOperationPreview o

-- | The <a>ready</a> signal gets emitted once per preview operation,
--   before the first page is rendered.
--   
--   A handler for this signal can be used for setup tasks.
type PrintOperationPreviewReadyCallback = PrintContext -> IO ()

-- | The <a>gotPageSize</a> signal is emitted once for each page that gets
--   rendered to the preview.
--   
--   A handler for this signal should update the <i><tt>context</tt></i>
--   according to <i><tt>pageSetup</tt></i> and set up a suitable cairo
--   context, using <a>printContextSetCairoContext</a>.
type PrintOperationPreviewGotPageSizeCallback = PrintContext -> PageSetup -> IO ()

-- | Memory-managed wrapper type.
newtype () => RadioActionEntry
RadioActionEntry :: ManagedPtr RadioActionEntry -> RadioActionEntry

-- | Memory-managed wrapper type.
newtype () => RcContext
RcContext :: ManagedPtr RcContext -> RcContext

-- | Memory-managed wrapper type.
newtype () => RcProperty
RcProperty :: ManagedPtr RcProperty -> RcProperty

-- | Type class for types which can be safely cast to <a>RecentManager</a>,
--   for instance with <a>toRecentManager</a>.
class (GObject o, IsDescendantOf RecentManager o) => IsRecentManager o

-- | Emitted when the current recently used resources manager changes its
--   contents, either by calling <a>recentManagerAddItem</a> or by another
--   application.
--   
--   <i>Since: 2.10</i>
type RecentManagerChangedCallback = IO ()

-- | Memory-managed wrapper type.
newtype () => RequestedSize
RequestedSize :: ManagedPtr RequestedSize -> RequestedSize

-- | Memory-managed wrapper type.
newtype () => SettingsValue
SettingsValue :: ManagedPtr SettingsValue -> SettingsValue

-- | Memory-managed wrapper type.
newtype () => TableRowCol
TableRowCol :: ManagedPtr TableRowCol -> TableRowCol

-- | Memory-managed wrapper type.
newtype () => TargetPair
TargetPair :: ManagedPtr TargetPair -> TargetPair

-- | Memory-managed wrapper type.
newtype () => TextAppearance
TextAppearance :: ManagedPtr TextAppearance -> TextAppearance

-- | Memory-managed wrapper type.
newtype () => TextBTree
TextBTree :: ManagedPtr TextBTree -> TextBTree

-- | Memory-managed wrapper type.
newtype () => ThemeEngine
ThemeEngine :: ManagedPtr ThemeEngine -> ThemeEngine

-- | Memory-managed wrapper type.
newtype () => ToggleActionEntry
ToggleActionEntry :: ManagedPtr ToggleActionEntry -> ToggleActionEntry

-- | Type class for types which can be safely cast to <a>Calendar</a>, for
--   instance with <a>toCalendar</a>.
class (GObject o, IsDescendantOf Calendar o) => IsCalendar o

-- | Type class for types which can be safely cast to <a>FlowBox</a>, for
--   instance with <a>toFlowBox</a>.
class (GObject o, IsDescendantOf FlowBox o) => IsFlowBox o

-- | Type class for types which can be safely cast to <a>FlowBoxChild</a>,
--   for instance with <a>toFlowBoxChild</a>.
class (GObject o, IsDescendantOf FlowBoxChild o) => IsFlowBoxChild o

-- | Type class for types which can be safely cast to <a>IconView</a>, for
--   instance with <a>toIconView</a>.
class (GObject o, IsDescendantOf IconView o) => IsIconView o

-- | Type class for types which can be safely cast to <a>ListBox</a>, for
--   instance with <a>toListBox</a>.
class (GObject o, IsDescendantOf ListBox o) => IsListBox o

-- | Type class for types which can be safely cast to <a>ListBoxRow</a>,
--   for instance with <a>toListBoxRow</a>.
class (GObject o, IsDescendantOf ListBoxRow o) => IsListBoxRow o

-- | Type class for types which can be safely cast to <a>Actionable</a>,
--   for instance with <a>toActionable</a>.
class (GObject o, IsDescendantOf Actionable o) => IsActionable o

-- | Type class for types which can be safely cast to <a>Activatable</a>,
--   for instance with <a>toActivatable</a>.
class (GObject o, IsDescendantOf Activatable o) => IsActivatable o

-- | Type class for types which can be safely cast to <a>Action</a>, for
--   instance with <a>toAction</a>.
class (GObject o, IsDescendantOf Action o) => IsAction o

-- | Type class for types which can be safely cast to <a>ActionGroup</a>,
--   for instance with <a>toActionGroup</a>.
class (GObject o, IsDescendantOf ActionGroup o) => IsActionGroup o

-- | Type class for types which can be safely cast to <a>Menu</a>, for
--   instance with <a>toMenu</a>.
class (GObject o, IsDescendantOf Menu o) => IsMenu o

-- | Type class for types which can be safely cast to <a>MenuItem</a>, for
--   instance with <a>toMenuItem</a>.
class (GObject o, IsDescendantOf MenuItem o) => IsMenuItem o

-- | Type class for types which can be safely cast to <a>MenuShell</a>, for
--   instance with <a>toMenuShell</a>.
class (GObject o, IsDescendantOf MenuShell o) => IsMenuShell o

-- | Type class for types which can be safely cast to <a>Entry</a>, for
--   instance with <a>toEntry</a>.
class (GObject o, IsDescendantOf Entry o) => IsEntry o

-- | Type class for types which can be safely cast to
--   <a>EntryCompletion</a>, for instance with <a>toEntryCompletion</a>.
class (GObject o, IsDescendantOf EntryCompletion o) => IsEntryCompletion o

-- | Type class for types which can be safely cast to <a>TreeSelection</a>,
--   for instance with <a>toTreeSelection</a>.
class (GObject o, IsDescendantOf TreeSelection o) => IsTreeSelection o

-- | Type class for types which can be safely cast to <a>TreeView</a>, for
--   instance with <a>toTreeView</a>.
class (GObject o, IsDescendantOf TreeView o) => IsTreeView o

-- | Type class for types which can be safely cast to <a>CellLayout</a>,
--   for instance with <a>toCellLayout</a>.
class (GObject o, IsDescendantOf CellLayout o) => IsCellLayout o

-- | Type class for types which can be safely cast to <a>TreeModel</a>, for
--   instance with <a>toTreeModel</a>.
class (GObject o, IsDescendantOf TreeModel o) => IsTreeModel o

-- | Type class for types which can be safely cast to <a>CellArea</a>, for
--   instance with <a>toCellArea</a>.
class (GObject o, IsDescendantOf CellArea o) => IsCellArea o

-- | Type class for types which can be safely cast to
--   <a>CellAreaContext</a>, for instance with <a>toCellAreaContext</a>.
class (GObject o, IsDescendantOf CellAreaContext o) => IsCellAreaContext o

-- | Type class for types which can be safely cast to <a>CellEditable</a>,
--   for instance with <a>toCellEditable</a>.
class (GObject o, IsDescendantOf CellEditable o) => IsCellEditable o

-- | Type class for types which can be safely cast to <a>Buildable</a>, for
--   instance with <a>toBuildable</a>.
class (GObject o, IsDescendantOf Buildable o) => IsBuildable o

-- | Type class for types which implement <a>StyleProvider</a>.
class (ManagedPtrNewtype o, IsDescendantOf StyleProvider o) => IsStyleProvider o

-- | Type class for types which can be safely cast to <a>CellRenderer</a>,
--   for instance with <a>toCellRenderer</a>.
class (GObject o, IsDescendantOf CellRenderer o) => IsCellRenderer o

-- | Type class for types which can be safely cast to
--   <a>TreeViewColumn</a>, for instance with <a>toTreeViewColumn</a>.
class (GObject o, IsDescendantOf TreeViewColumn o) => IsTreeViewColumn o

-- | Type class for types which can be safely cast to <a>AccelGroup</a>,
--   for instance with <a>toAccelGroup</a>.
class (GObject o, IsDescendantOf AccelGroup o) => IsAccelGroup o

-- | Type class for types which can be safely cast to <a>Application</a>,
--   for instance with <a>toApplication</a>.
class (GObject o, IsDescendantOf Application o) => IsApplication o

-- | Type class for types which can be safely cast to <a>Bin</a>, for
--   instance with <a>toBin</a>.
class (GObject o, IsDescendantOf Bin o) => IsBin o

-- | Type class for types which can be safely cast to <a>Builder</a>, for
--   instance with <a>toBuilder</a>.
class (GObject o, IsDescendantOf Builder o) => IsBuilder o

-- | Type class for types which can be safely cast to <a>Clipboard</a>, for
--   instance with <a>toClipboard</a>.
class (GObject o, IsDescendantOf Clipboard o) => IsClipboard o

-- | Type class for types which can be safely cast to <a>Container</a>, for
--   instance with <a>toContainer</a>.
class (GObject o, IsDescendantOf Container o) => IsContainer o

-- | Type class for types which can be safely cast to <a>IconFactory</a>,
--   for instance with <a>toIconFactory</a>.
class (GObject o, IsDescendantOf IconFactory o) => IsIconFactory o

-- | Type class for types which can be safely cast to <a>Settings</a>, for
--   instance with <a>toSettings</a>.
class (GObject o, IsDescendantOf Settings o) => IsSettings o

-- | Type class for types which can be safely cast to <a>Style</a>, for
--   instance with <a>toStyle</a>.
class (GObject o, IsDescendantOf Style o) => IsStyle o

-- | Type class for types which can be safely cast to <a>StyleContext</a>,
--   for instance with <a>toStyleContext</a>.
class (GObject o, IsDescendantOf StyleContext o) => IsStyleContext o

-- | Type class for types which can be safely cast to
--   <a>StyleProperties</a>, for instance with <a>toStyleProperties</a>.
class (GObject o, IsDescendantOf StyleProperties o) => IsStyleProperties o

-- | Type class for types which can be safely cast to <a>TextBuffer</a>,
--   for instance with <a>toTextBuffer</a>.
class (GObject o, IsDescendantOf TextBuffer o) => IsTextBuffer o

-- | Type class for types which can be safely cast to
--   <a>TextChildAnchor</a>, for instance with <a>toTextChildAnchor</a>.
class (GObject o, IsDescendantOf TextChildAnchor o) => IsTextChildAnchor o

-- | Type class for types which can be safely cast to <a>TextMark</a>, for
--   instance with <a>toTextMark</a>.
class (GObject o, IsDescendantOf TextMark o) => IsTextMark o

-- | Type class for types which can be safely cast to <a>TextTag</a>, for
--   instance with <a>toTextTag</a>.
class (GObject o, IsDescendantOf TextTag o) => IsTextTag o

-- | Type class for types which can be safely cast to <a>TextTagTable</a>,
--   for instance with <a>toTextTagTable</a>.
class (GObject o, IsDescendantOf TextTagTable o) => IsTextTagTable o

-- | Type class for types which can be safely cast to <a>Tooltip</a>, for
--   instance with <a>toTooltip</a>.
class (GObject o, IsDescendantOf Tooltip o) => IsTooltip o

-- | Type class for types which can be safely cast to <a>Widget</a>, for
--   instance with <a>toWidget</a>.
class (GObject o, IsDescendantOf Widget o) => IsWidget o

-- | Type class for types which can be safely cast to <a>WindowGroup</a>,
--   for instance with <a>toWindowGroup</a>.
class (GObject o, IsDescendantOf WindowGroup o) => IsWindowGroup o

-- | Type for the callback on the (unwrapped) C side.
type C_AccelGroupActivate = Ptr AccelGroup -> Ptr Object -> Word32 -> CUInt -> IO CInt

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2.2</i>
type AccelGroupFindFunc_WithClosures = AccelKey -> GClosure () -> Ptr () -> IO Bool

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2.2</i>
type AccelGroupFindFunc = AccelKey -> GClosure () -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_AccelGroupFindFunc = Ptr AccelKey -> Ptr GClosure () -> Ptr () -> IO CInt

-- | Type for the callback on the (unwrapped) C side.
type C_AccelMapForeach = Ptr () -> CString -> Word32 -> CUInt -> CInt -> IO ()

-- | <i>No description available in the introspection data.</i>
type ActionableInterfaceGetActionNameFieldCallback = Actionable -> IO Maybe Text

-- | Type for the callback on the (unwrapped) C side.
type C_ActionableInterfaceGetActionNameFieldCallback = Ptr Actionable -> IO CString

-- | <i>No description available in the introspection data.</i>
type ActionableInterfaceGetActionTargetValueFieldCallback = Actionable -> IO GVariant

-- | Type for the callback on the (unwrapped) C side.
type C_ActionableInterfaceGetActionTargetValueFieldCallback = Ptr Actionable -> IO Ptr GVariant

-- | <i>No description available in the introspection data.</i>
type ActionableInterfaceSetActionNameFieldCallback = Actionable -> Maybe Text -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ActionableInterfaceSetActionNameFieldCallback = Ptr Actionable -> CString -> IO ()

-- | <i>No description available in the introspection data.</i>
type ActionableInterfaceSetActionTargetValueFieldCallback = Actionable -> Maybe GVariant -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ActionableInterfaceSetActionTargetValueFieldCallback = Ptr Actionable -> Ptr GVariant -> IO ()

-- | A function used by <a>assistantSetForwardPageFunc</a> to know which is
--   the next page given a current one. It’s called both for computing the
--   next page when the user presses the “forward” button and for handling
--   the behavior of the “last” button.
type AssistantPageFunc_WithClosures = Int32 -> Ptr () -> IO Int32

-- | Type for the callback on the (unwrapped) C side.
type C_AssistantPageFunc = Int32 -> Ptr () -> IO Int32

-- | This is the signature of a function used to connect signals. It is
--   used by the <a>builderConnectSignals</a> and
--   <a>builderConnectSignalsFull</a> methods. It is mainly intended for
--   interpreted language bindings, but could be useful where the
--   programmer wants more control over the signal connection process. Note
--   that this function can only be called once, subsequent calls will do
--   nothing.
--   
--   <i>Since: 2.12</i>
type BuilderConnectFunc_WithClosures = Builder -> Object -> Text -> Text -> Maybe Object -> [ConnectFlags] -> Ptr () -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_BuilderConnectFunc = Ptr Builder -> Ptr Object -> CString -> CString -> Ptr Object -> CUInt -> Ptr () -> IO ()

-- | This kind of functions provide Pango markup with detail information
--   for the specified day. Examples for such details are holidays or
--   appointments. The function returns <a>Nothing</a> when no information
--   is available.
--   
--   <i>Since: 2.14</i>
type CalendarDetailFunc_WithClosures = Calendar -> Word32 -> Word32 -> Word32 -> Ptr () -> IO Maybe Text

-- | This kind of functions provide Pango markup with detail information
--   for the specified day. Examples for such details are holidays or
--   appointments. The function returns <a>Nothing</a> when no information
--   is available.
--   
--   <i>Since: 2.14</i>
type CalendarDetailFunc = Calendar -> Word32 -> Word32 -> Word32 -> IO Maybe Text

-- | Type for the callback on the (unwrapped) C side.
type C_CalendarDetailFunc = Ptr Calendar -> Word32 -> Word32 -> Word32 -> Ptr () -> IO CString

-- | The type of the callback functions used for e.g. iterating over the
--   children of a container, see <a>containerForeach</a>.
type Callback_WithClosures = Widget -> Ptr () -> IO ()

-- | The type of the callback functions used for iterating over the cell
--   renderers and their allocated areas inside a <a>CellArea</a>, see
--   <a>cellAreaForeachAlloc</a>.
type CellAllocCallback_WithClosures = CellRenderer -> Rectangle -> Rectangle -> Ptr () -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_CellAllocCallback = Ptr CellRenderer -> Ptr Rectangle -> Ptr Rectangle -> Ptr () -> IO CInt

-- | The type of the callback functions used for iterating over the cell
--   renderers of a <a>CellArea</a>, see <a>cellAreaForeach</a>.
type CellCallback_WithClosures = CellRenderer -> Ptr () -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_CellCallback = Ptr CellRenderer -> Ptr () -> IO CInt

-- | A function which should set the value of <i><tt>cellLayout</tt></i>’s
--   cell renderer(s) as appropriate.
type CellLayoutDataFunc_WithClosures = CellLayout -> CellRenderer -> TreeModel -> TreeIter -> Ptr () -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_CellLayoutDataFunc = Ptr CellLayout -> Ptr CellRenderer -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO ()

-- | A function that will be called when the contents of the clipboard are
--   changed or cleared. Once this has called, the
--   <i><tt>userDataOrOwner</tt></i> argument will not be used again.
type ClipboardClearFunc_WithClosures = Clipboard -> Ptr () -> IO ()

-- | A function that will be called when the contents of the clipboard are
--   changed or cleared. Once this has called, the
--   <i><tt>userDataOrOwner</tt></i> argument will not be used again.
type ClipboardClearFunc = Clipboard -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ClipboardClearFunc = Ptr Clipboard -> Ptr () -> IO ()

-- | A function that will be called to provide the contents of the
--   selection. If multiple types of data were advertised, the requested
--   type can be determined from the <i><tt>info</tt></i> parameter or by
--   checking the target field of <i><tt>selectionData</tt></i>. If the
--   data could successfully be converted into then it should be stored
--   into the <i><tt>selectionData</tt></i> object by calling
--   <a>selectionDataSet</a> (or related functions such as
--   <a>selectionDataSetText</a>). If no data is set, the requestor will be
--   informed that the attempt to get the data failed.
type ClipboardGetFunc_WithClosures = Clipboard -> SelectionData -> Word32 -> Ptr () -> IO ()

-- | A function that will be called to provide the contents of the
--   selection. If multiple types of data were advertised, the requested
--   type can be determined from the <i><tt>info</tt></i> parameter or by
--   checking the target field of <i><tt>selectionData</tt></i>. If the
--   data could successfully be converted into then it should be stored
--   into the <i><tt>selectionData</tt></i> object by calling
--   <a>selectionDataSet</a> (or related functions such as
--   <a>selectionDataSetText</a>). If no data is set, the requestor will be
--   informed that the attempt to get the data failed.
type ClipboardGetFunc = Clipboard -> SelectionData -> Word32 -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ClipboardGetFunc = Ptr Clipboard -> Ptr SelectionData -> Word32 -> Ptr () -> IO ()

-- | A function to be called when the results of
--   <a>clipboardRequestImage</a> are received, or when the request fails.
--   
--   <i>Since: 2.6</i>
type ClipboardImageReceivedFunc_WithClosures = Clipboard -> Maybe Pixbuf -> Ptr () -> IO ()

-- | A function to be called when the results of
--   <a>clipboardRequestImage</a> are received, or when the request fails.
--   
--   <i>Since: 2.6</i>
type ClipboardImageReceivedFunc = Clipboard -> Maybe Pixbuf -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ClipboardImageReceivedFunc = Ptr Clipboard -> Ptr Pixbuf -> Ptr () -> IO ()

-- | A function to be called when the results of
--   <a>clipboardRequestContents</a> are received, or when the request
--   fails.
type ClipboardReceivedFunc_WithClosures = Clipboard -> SelectionData -> Ptr () -> IO ()

-- | A function to be called when the results of
--   <a>clipboardRequestContents</a> are received, or when the request
--   fails.
type ClipboardReceivedFunc = Clipboard -> SelectionData -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ClipboardReceivedFunc = Ptr Clipboard -> Ptr SelectionData -> Ptr () -> IO ()

-- | A function to be called when the results of
--   <a>clipboardRequestRichText</a> are received, or when the request
--   fails.
--   
--   <i>Since: 2.10</i>
type ClipboardRichTextReceivedFunc_WithClosures = Clipboard -> Atom -> Maybe Text -> CSize -> Ptr () -> IO ()

-- | A function to be called when the results of
--   <a>clipboardRequestRichText</a> are received, or when the request
--   fails.
--   
--   <i>Since: 2.10</i>
type ClipboardRichTextReceivedFunc = Clipboard -> Atom -> Maybe Text -> CSize -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ClipboardRichTextReceivedFunc = Ptr Clipboard -> Ptr Atom -> CString -> CSize -> Ptr () -> IO ()

-- | A function to be called when the results of
--   <a>clipboardRequestTargets</a> are received, or when the request
--   fails.
--   
--   <i>Since: 2.4</i>
type ClipboardTargetsReceivedFunc_WithClosures = Clipboard -> Maybe [Atom] -> Ptr () -> IO ()

-- | A function to be called when the results of
--   <a>clipboardRequestTargets</a> are received, or when the request
--   fails.
--   
--   <i>Since: 2.4</i>
type ClipboardTargetsReceivedFunc = Clipboard -> Maybe [Atom] -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ClipboardTargetsReceivedFunc = Ptr Clipboard -> Ptr Ptr Atom -> Int32 -> Ptr () -> IO ()

-- | A function to be called when the results of
--   <a>clipboardRequestText</a> are received, or when the request fails.
type ClipboardTextReceivedFunc_WithClosures = Clipboard -> Maybe Text -> Ptr () -> IO ()

-- | A function to be called when the results of
--   <a>clipboardRequestText</a> are received, or when the request fails.
type ClipboardTextReceivedFunc = Clipboard -> Maybe Text -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ClipboardTextReceivedFunc = Ptr Clipboard -> CString -> Ptr () -> IO ()

-- | A function to be called when the results of
--   <a>clipboardRequestUris</a> are received, or when the request fails.
--   
--   <i>Since: 2.14</i>
type ClipboardURIReceivedFunc_WithClosures = Clipboard -> [Text] -> Ptr () -> IO ()

-- | A function to be called when the results of
--   <a>clipboardRequestUris</a> are received, or when the request fails.
--   
--   <i>Since: 2.14</i>
type ClipboardURIReceivedFunc = Clipboard -> [Text] -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ClipboardURIReceivedFunc = Ptr Clipboard -> Ptr CString -> Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type ColorSelectionChangePaletteFunc = [Color] -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ColorSelectionChangePaletteFunc = Ptr Color -> Int32 -> IO ()

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2.2</i>
type ColorSelectionChangePaletteWithScreenFunc = Screen -> [Color] -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ColorSelectionChangePaletteWithScreenFunc = Ptr Screen -> Ptr Color -> Int32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type ContainerClassAddFieldCallback = Container -> Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ContainerClassAddFieldCallback = Ptr Container -> Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type ContainerClassCheckResizeFieldCallback = Container -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ContainerClassCheckResizeFieldCallback = Ptr Container -> IO ()

-- | <i>No description available in the introspection data.</i>
type ContainerClassChildTypeFieldCallback = Container -> IO GType

-- | Type for the callback on the (unwrapped) C side.
type C_ContainerClassChildTypeFieldCallback = Ptr Container -> IO CGType

-- | <i>No description available in the introspection data.</i>
type ContainerClassCompositeNameFieldCallback = Container -> Widget -> IO Text

-- | Type for the callback on the (unwrapped) C side.
type C_ContainerClassCompositeNameFieldCallback = Ptr Container -> Ptr Widget -> IO CString

-- | <i>No description available in the introspection data.</i>
type ContainerClassForallFieldCallback_WithClosures = Container -> Bool -> Callback_WithClosures -> Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type ContainerClassForallFieldCallback = Container -> Bool -> Callback_WithClosures -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ContainerClassForallFieldCallback = Ptr Container -> CInt -> FunPtr C_Callback -> Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type ContainerClassGetChildPropertyFieldCallback = Container -> Widget -> Word32 -> GValue -> GParamSpec -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ContainerClassGetChildPropertyFieldCallback = Ptr Container -> Ptr Widget -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()

-- | <i>No description available in the introspection data.</i>
type ContainerClassGetPathForChildFieldCallback = Container -> Widget -> IO WidgetPath

-- | Type for the callback on the (unwrapped) C side.
type C_ContainerClassGetPathForChildFieldCallback = Ptr Container -> Ptr Widget -> IO Ptr WidgetPath

-- | <i>No description available in the introspection data.</i>
type ContainerClassRemoveFieldCallback = Container -> Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ContainerClassRemoveFieldCallback = Ptr Container -> Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type ContainerClassSetChildPropertyFieldCallback = Container -> Widget -> Word32 -> GValue -> GParamSpec -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ContainerClassSetChildPropertyFieldCallback = Ptr Container -> Ptr Widget -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()

-- | <i>No description available in the introspection data.</i>
type ContainerClassSetFocusChildFieldCallback = Container -> Maybe Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ContainerClassSetFocusChildFieldCallback = Ptr Container -> Ptr Widget -> IO ()

-- | A function which decides whether the row indicated by
--   <i><tt>iter</tt></i> matches a given <i><tt>key</tt></i>, and should
--   be displayed as a possible completion for <i><tt>key</tt></i>. Note
--   that <i><tt>key</tt></i> is normalized and case-folded (see
--   <a>utf8Normalize</a> and <a>utf8Casefold</a>). If this is not
--   appropriate, match functions have access to the unmodified key via
--   <tt>gtk_entry_get_text (GTK_ENTRY (gtk_entry_completion_get_entry
--   ()))</tt>.
type EntryCompletionMatchFunc_WithClosures = EntryCompletion -> Text -> TreeIter -> Ptr () -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_EntryCompletionMatchFunc = Ptr EntryCompletion -> CString -> Ptr TreeIter -> Ptr () -> IO CInt

-- | The type of function that is used with custom filters, see
--   <a>fileFilterAddCustom</a>.
type FileFilterFunc_WithClosures = FileFilterInfo -> Ptr () -> IO Bool

-- | The type of function that is used with custom filters, see
--   <a>fileFilterAddCustom</a>.
type FileFilterFunc = FileFilterInfo -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_FileFilterFunc = Ptr FileFilterInfo -> Ptr () -> IO CInt

-- | Called for flow boxes that are bound to a <a>ListModel</a> with
--   <a>flowBoxBindModel</a> for each item that gets added to the model.
--   
--   <i>Since: 3.18</i>
type FlowBoxCreateWidgetFunc_WithClosures = Maybe Object -> Ptr () -> IO Widget

-- | Called for flow boxes that are bound to a <a>ListModel</a> with
--   <a>flowBoxBindModel</a> for each item that gets added to the model.
--   
--   <i>Since: 3.18</i>
type FlowBoxCreateWidgetFunc = Maybe Object -> IO Widget

-- | Type for the callback on the (unwrapped) C side.
type C_FlowBoxCreateWidgetFunc = Ptr Object -> Ptr () -> IO Ptr Widget

-- | A function that will be called whenrever a child changes or is added.
--   It lets you control if the child should be visible or not.
--   
--   <i>Since: 3.12</i>
type FlowBoxFilterFunc_WithClosures = FlowBoxChild -> Ptr () -> IO Bool

-- | A function that will be called whenrever a child changes or is added.
--   It lets you control if the child should be visible or not.
--   
--   <i>Since: 3.12</i>
type FlowBoxFilterFunc = FlowBoxChild -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_FlowBoxFilterFunc = Ptr FlowBoxChild -> Ptr () -> IO CInt

-- | A function used by <a>flowBoxSelectedForeach</a>. It will be called on
--   every selected child of the <i><tt>box</tt></i>.
--   
--   <i>Since: 3.12</i>
type FlowBoxForeachFunc_WithClosures = FlowBox -> FlowBoxChild -> Ptr () -> IO ()

-- | A function used by <a>flowBoxSelectedForeach</a>. It will be called on
--   every selected child of the <i><tt>box</tt></i>.
--   
--   <i>Since: 3.12</i>
type FlowBoxForeachFunc = FlowBox -> FlowBoxChild -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_FlowBoxForeachFunc = Ptr FlowBox -> Ptr FlowBoxChild -> Ptr () -> IO ()

-- | A function to compare two children to determine which should come
--   first.
--   
--   <i>Since: 3.12</i>
type FlowBoxSortFunc_WithClosures = FlowBoxChild -> FlowBoxChild -> Ptr () -> IO Int32

-- | A function to compare two children to determine which should come
--   first.
--   
--   <i>Since: 3.12</i>
type FlowBoxSortFunc = FlowBoxChild -> FlowBoxChild -> IO Int32

-- | Type for the callback on the (unwrapped) C side.
type C_FlowBoxSortFunc = Ptr FlowBoxChild -> Ptr FlowBoxChild -> Ptr () -> IO Int32

-- | The type of function that is used for deciding what fonts get shown in
--   a <a>FontChooser</a>. See <a>fontChooserSetFilterFunc</a>.
type FontFilterFunc_WithClosures = FontFamily -> FontFace -> Ptr () -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_FontFilterFunc = Ptr FontFamily -> Ptr FontFace -> Ptr () -> IO CInt

-- | A function used by <a>iconViewSelectedForeach</a> to map all selected
--   rows. It will be called on every selected row in the view.
type IconViewForeachFunc_WithClosures = IconView -> TreePath -> Ptr () -> IO ()

-- | A function used by <a>iconViewSelectedForeach</a> to map all selected
--   rows. It will be called on every selected row in the view.
type IconViewForeachFunc = IconView -> TreePath -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_IconViewForeachFunc = Ptr IconView -> Ptr TreePath -> Ptr () -> IO ()

-- | Key snooper functions are called before normal event delivery. They
--   can be used to implement custom key event handling.
type KeySnoopFunc_WithClosures = Widget -> EventKey -> Ptr () -> IO Int32

-- | Key snooper functions are called before normal event delivery. They
--   can be used to implement custom key event handling.
type KeySnoopFunc = Widget -> EventKey -> IO Int32

-- | Type for the callback on the (unwrapped) C side.
type C_KeySnoopFunc = Ptr Widget -> Ptr EventKey -> Ptr () -> IO Int32

-- | Called for list boxes that are bound to a <a>ListModel</a> with
--   <a>listBoxBindModel</a> for each item that gets added to the model.
--   
--   Versions of GTK+ prior to 3.18 called <a>widgetShowAll</a> on the rows
--   created by the GtkListBoxCreateWidgetFunc, but this forced all widgets
--   inside the row to be shown, and is no longer the case. Applications
--   should be updated to show the desired row widgets.
--   
--   <i>Since: 3.16</i>
type ListBoxCreateWidgetFunc_WithClosures = Object -> Ptr () -> IO Widget

-- | Called for list boxes that are bound to a <a>ListModel</a> with
--   <a>listBoxBindModel</a> for each item that gets added to the model.
--   
--   Versions of GTK+ prior to 3.18 called <a>widgetShowAll</a> on the rows
--   created by the GtkListBoxCreateWidgetFunc, but this forced all widgets
--   inside the row to be shown, and is no longer the case. Applications
--   should be updated to show the desired row widgets.
--   
--   <i>Since: 3.16</i>
type ListBoxCreateWidgetFunc = Object -> IO Widget

-- | Type for the callback on the (unwrapped) C side.
type C_ListBoxCreateWidgetFunc = Ptr Object -> Ptr () -> IO Ptr Widget

-- | Will be called whenever the row changes or is added and lets you
--   control if the row should be visible or not.
--   
--   <i>Since: 3.10</i>
type ListBoxFilterFunc_WithClosures = ListBoxRow -> Ptr () -> IO Bool

-- | Will be called whenever the row changes or is added and lets you
--   control if the row should be visible or not.
--   
--   <i>Since: 3.10</i>
type ListBoxFilterFunc = ListBoxRow -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_ListBoxFilterFunc = Ptr ListBoxRow -> Ptr () -> IO CInt

-- | A function used by <a>listBoxSelectedForeach</a>. It will be called on
--   every selected child of the <i><tt>box</tt></i>.
--   
--   <i>Since: 3.14</i>
type ListBoxForeachFunc_WithClosures = ListBox -> ListBoxRow -> Ptr () -> IO ()

-- | A function used by <a>listBoxSelectedForeach</a>. It will be called on
--   every selected child of the <i><tt>box</tt></i>.
--   
--   <i>Since: 3.14</i>
type ListBoxForeachFunc = ListBox -> ListBoxRow -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ListBoxForeachFunc = Ptr ListBox -> Ptr ListBoxRow -> Ptr () -> IO ()

-- | Compare two rows to determine which should be first.
--   
--   <i>Since: 3.10</i>
type ListBoxSortFunc_WithClosures = ListBoxRow -> ListBoxRow -> Ptr () -> IO Int32

-- | Compare two rows to determine which should be first.
--   
--   <i>Since: 3.10</i>
type ListBoxSortFunc = ListBoxRow -> ListBoxRow -> IO Int32

-- | Type for the callback on the (unwrapped) C side.
type C_ListBoxSortFunc = Ptr ListBoxRow -> Ptr ListBoxRow -> Ptr () -> IO Int32

-- | Whenever <i><tt>row</tt></i> changes or which row is before
--   <i><tt>row</tt></i> changes this is called, which lets you update the
--   header on <i><tt>row</tt></i>. You may remove or set a new one via
--   <a>listBoxRowSetHeader</a> or just change the state of the current
--   header widget.
--   
--   <i>Since: 3.10</i>
type ListBoxUpdateHeaderFunc_WithClosures = ListBoxRow -> Maybe ListBoxRow -> Ptr () -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ListBoxUpdateHeaderFunc = Ptr ListBoxRow -> Ptr ListBoxRow -> Ptr () -> IO ()

-- | A user function supplied when calling <a>menuAttachToWidget</a> which
--   will be called when the menu is later detached from the widget.
type MenuDetachFunc = Widget -> Menu -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_MenuDetachFunc = Ptr Widget -> Ptr Menu -> IO ()

-- | A user function supplied when calling <a>menuPopup</a> which controls
--   the positioning of the menu when it is displayed. The function sets
--   the <i><tt>x</tt></i> and <i><tt>y</tt></i> parameters to the
--   coordinates where the menu is to be drawn. To make the menu appear on
--   a different monitor than the mouse pointer, <a>menuSetMonitor</a> must
--   be called.
type MenuPositionFunc_WithClosures = Menu -> Int32 -> Int32 -> Ptr () -> IO (Int32, Int32, Bool)

-- | Type for the callback on the (unwrapped) C side.
type C_MenuPositionFunc = Ptr Menu -> Ptr Int32 -> Ptr Int32 -> Ptr CInt -> Ptr () -> IO ()

-- | A multihead-aware GTK+ module may have a
--   <tt><i>gtk_module_display_init()</i></tt> function with this
--   prototype. GTK+ calls this function for each opened display.
--   
--   <i>Since: 2.2</i>
type ModuleDisplayInitFunc = Display -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ModuleDisplayInitFunc = Ptr Display -> IO ()

-- | Each GTK+ module must have a function
--   <tt><i>gtk_module_init()</i></tt> with this prototype. This function
--   is called after loading the module.
type ModuleInitFunc = Maybe [Text] -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_ModuleInitFunc = Int32 -> Ptr CString -> IO ()

-- | The type of function that is passed to
--   <a>printRunPageSetupDialogAsync</a>.
--   
--   This function will be called when the page setup dialog is dismissed,
--   and also serves as destroy notify for <i><tt>data</tt></i>.
type PageSetupDoneFunc_WithClosures = PageSetup -> Ptr () -> IO ()

-- | The type of function that is passed to
--   <a>printRunPageSetupDialogAsync</a>.
--   
--   This function will be called when the page setup dialog is dismissed,
--   and also serves as destroy notify for <i><tt>data</tt></i>.
type PageSetupDoneFunc = PageSetup -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_PageSetupDoneFunc = Ptr PageSetup -> Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type PrintSettingsFunc_WithClosures = Text -> Text -> Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type PrintSettingsFunc = Text -> Text -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_PrintSettingsFunc = CString -> CString -> Ptr () -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_RcPropertyParser = Ptr GParamSpec -> Ptr String -> Ptr GValue -> IO CInt

-- | The type of function that is used with custom filters, see
--   <a>recentFilterAddCustom</a>.
type RecentFilterFunc_WithClosures = RecentFilterInfo -> Ptr () -> IO Bool

-- | The type of function that is used with custom filters, see
--   <a>recentFilterAddCustom</a>.
type RecentFilterFunc = RecentFilterInfo -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_RecentFilterFunc = Ptr RecentFilterInfo -> Ptr () -> IO CInt

-- | <i>No description available in the introspection data.</i>
type RecentSortFunc_WithClosures = RecentInfo -> RecentInfo -> Ptr () -> IO Int32

-- | <i>No description available in the introspection data.</i>
type RecentSortFunc = RecentInfo -> RecentInfo -> IO Int32

-- | Type for the callback on the (unwrapped) C side.
type C_RecentSortFunc = Ptr RecentInfo -> Ptr RecentInfo -> Ptr () -> IO Int32

-- | <i>No description available in the introspection data.</i>
type StylePropertyParser = Text -> GValue -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_StylePropertyParser = CString -> Ptr GValue -> Ptr Ptr GError -> IO CInt

-- | A function that is called to deserialize rich text that has been
--   serialized with <a>textBufferSerialize</a>, and insert it at
--   <i><tt>iter</tt></i>.
type TextBufferDeserializeFunc_WithClosures = TextBuffer -> TextBuffer -> TextIter -> ByteString -> Bool -> Ptr () -> IO ()

-- | A function that is called to deserialize rich text that has been
--   serialized with <a>textBufferSerialize</a>, and insert it at
--   <i><tt>iter</tt></i>.
type TextBufferDeserializeFunc = TextBuffer -> TextBuffer -> TextIter -> ByteString -> Bool -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_TextBufferDeserializeFunc = Ptr TextBuffer -> Ptr TextBuffer -> Ptr TextIter -> Ptr Word8 -> CSize -> CInt -> Ptr () -> Ptr Ptr GError -> IO CInt

-- | A function that is called to serialize the content of a text buffer.
--   It must return the serialized form of the content.
type TextBufferSerializeFunc_WithClosures = TextBuffer -> TextBuffer -> TextIter -> TextIter -> Ptr () -> IO Maybe ByteString

-- | A function that is called to serialize the content of a text buffer.
--   It must return the serialized form of the content.
type TextBufferSerializeFunc = TextBuffer -> TextBuffer -> TextIter -> TextIter -> IO Maybe ByteString

-- | Type for the callback on the (unwrapped) C side.
type C_TextBufferSerializeFunc = Ptr TextBuffer -> Ptr TextBuffer -> Ptr TextIter -> Ptr TextIter -> Ptr CSize -> Ptr () -> IO Ptr Word8

-- | <i>No description available in the introspection data.</i>
type TextCharPredicate_WithClosures = Char -> Ptr () -> IO Bool

-- | <i>No description available in the introspection data.</i>
type TextCharPredicate = Char -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_TextCharPredicate = CInt -> Ptr () -> IO CInt

-- | <i>No description available in the introspection data.</i>
type TextTagTableForeach_WithClosures = TextTag -> Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type TextTagTableForeach = TextTag -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_TextTagTableForeach = Ptr TextTag -> Ptr () -> IO ()

-- | Callback type for adding a function to update animations. See
--   <a>widgetAddTickCallback</a>.
--   
--   <i>Since: 3.8</i>
type TickCallback_WithClosures = Widget -> FrameClock -> Ptr () -> IO Bool

-- | Callback type for adding a function to update animations. See
--   <a>widgetAddTickCallback</a>.
--   
--   <i>Since: 3.8</i>
type TickCallback = Widget -> FrameClock -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_TickCallback = Ptr Widget -> Ptr FrameClock -> Ptr () -> IO CInt

-- | A function to set the properties of a cell instead of just using the
--   straight mapping between the cell and the model. This is useful for
--   customizing the cell renderer. For example, a function might get an
--   integer from the <i><tt>treeModel</tt></i>, and render it to the
--   “text” attribute of “cell” by converting it to its written equivalent.
--   This is set by calling <a>treeViewColumnSetCellDataFunc</a>
type TreeCellDataFunc_WithClosures = TreeViewColumn -> CellRenderer -> TreeModel -> TreeIter -> Ptr () -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_TreeCellDataFunc = Ptr TreeViewColumn -> Ptr CellRenderer -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type TreeDestroyCountFunc_WithClosures = TreeView -> TreePath -> Int32 -> Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type TreeDestroyCountFunc = TreeView -> TreePath -> Int32 -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_TreeDestroyCountFunc = Ptr TreeView -> Ptr TreePath -> Int32 -> Ptr () -> IO ()

-- | A GtkTreeIterCompareFunc should return a negative integer, zero, or a
--   positive integer if <i><tt>a</tt></i> sorts before <i><tt>b</tt></i>,
--   <i><tt>a</tt></i> sorts with <i><tt>b</tt></i>, or <i><tt>a</tt></i>
--   sorts after <i><tt>b</tt></i> respectively. If two iters compare as
--   equal, their order in the sorted model is undefined. In order to
--   ensure that the <a>TreeSortable</a> behaves as expected, the
--   GtkTreeIterCompareFunc must define a partial order on the model, i.e.
--   it must be reflexive, antisymmetric and transitive.
--   
--   For example, if <i><tt>model</tt></i> is a product catalogue, then a
--   compare function for the “price” column could be one which returns
--   <tt>price_of(@a) - price_of(@b)</tt>.
type TreeIterCompareFunc_WithClosures = TreeModel -> TreeIter -> TreeIter -> Ptr () -> IO Int32

-- | A GtkTreeIterCompareFunc should return a negative integer, zero, or a
--   positive integer if <i><tt>a</tt></i> sorts before <i><tt>b</tt></i>,
--   <i><tt>a</tt></i> sorts with <i><tt>b</tt></i>, or <i><tt>a</tt></i>
--   sorts after <i><tt>b</tt></i> respectively. If two iters compare as
--   equal, their order in the sorted model is undefined. In order to
--   ensure that the <a>TreeSortable</a> behaves as expected, the
--   GtkTreeIterCompareFunc must define a partial order on the model, i.e.
--   it must be reflexive, antisymmetric and transitive.
--   
--   For example, if <i><tt>model</tt></i> is a product catalogue, then a
--   compare function for the “price” column could be one which returns
--   <tt>price_of(@a) - price_of(@b)</tt>.
type TreeIterCompareFunc = TreeModel -> TreeIter -> TreeIter -> IO Int32

-- | Type for the callback on the (unwrapped) C side.
type C_TreeIterCompareFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr TreeIter -> Ptr () -> IO Int32

-- | A function which calculates display values from raw values in the
--   model. It must fill <i><tt>value</tt></i> with the display value for
--   the column <i><tt>column</tt></i> in the row indicated by
--   <i><tt>iter</tt></i>.
--   
--   Since this function is called for each data access, it’s not a
--   particularly efficient operation.
type TreeModelFilterModifyFunc_WithClosures = TreeModel -> TreeIter -> Int32 -> Ptr () -> IO GValue

-- | A function which calculates display values from raw values in the
--   model. It must fill <i><tt>value</tt></i> with the display value for
--   the column <i><tt>column</tt></i> in the row indicated by
--   <i><tt>iter</tt></i>.
--   
--   Since this function is called for each data access, it’s not a
--   particularly efficient operation.
type TreeModelFilterModifyFunc = TreeModel -> TreeIter -> Int32 -> IO GValue

-- | Type for the callback on the (unwrapped) C side.
type C_TreeModelFilterModifyFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr GValue -> Int32 -> Ptr () -> IO ()

-- | A function which decides whether the row indicated by
--   <i><tt>iter</tt></i> is visible.
type TreeModelFilterVisibleFunc_WithClosures = TreeModel -> TreeIter -> Ptr () -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_TreeModelFilterVisibleFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO CInt

-- | Type of the callback passed to <a>treeModelForeach</a> to iterate over
--   the rows in a tree model.
type TreeModelForeachFunc_WithClosures = TreeModel -> TreePath -> TreeIter -> Ptr () -> IO Bool

-- | Type of the callback passed to <a>treeModelForeach</a> to iterate over
--   the rows in a tree model.
type TreeModelForeachFunc = TreeModel -> TreePath -> TreeIter -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_TreeModelForeachFunc = Ptr TreeModel -> Ptr TreePath -> Ptr TreeIter -> Ptr () -> IO CInt

-- | A function used by <a>treeSelectionSelectedForeach</a> to map all
--   selected rows. It will be called on every selected row in the view.
type TreeSelectionForeachFunc_WithClosures = TreeModel -> TreePath -> TreeIter -> Ptr () -> IO ()

-- | A function used by <a>treeSelectionSelectedForeach</a> to map all
--   selected rows. It will be called on every selected row in the view.
type TreeSelectionForeachFunc = TreeModel -> TreePath -> TreeIter -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_TreeSelectionForeachFunc = Ptr TreeModel -> Ptr TreePath -> Ptr TreeIter -> Ptr () -> IO ()

-- | A function used by <a>treeSelectionSetSelectFunction</a> to filter
--   whether or not a row may be selected. It is called whenever a row's
--   state might change. A return value of <a>True</a> indicates to
--   <i><tt>selection</tt></i> that it is okay to change the selection.
type TreeSelectionFunc_WithClosures = TreeSelection -> TreeModel -> TreePath -> Bool -> Ptr () -> IO Bool

-- | A function used by <a>treeSelectionSetSelectFunction</a> to filter
--   whether or not a row may be selected. It is called whenever a row's
--   state might change. A return value of <a>True</a> indicates to
--   <i><tt>selection</tt></i> that it is okay to change the selection.
type TreeSelectionFunc = TreeSelection -> TreeModel -> TreePath -> Bool -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_TreeSelectionFunc = Ptr TreeSelection -> Ptr TreeModel -> Ptr TreePath -> CInt -> Ptr () -> IO CInt

-- | Function type for determining whether <i><tt>column</tt></i> can be
--   dropped in a particular spot (as determined by
--   <i><tt>prevColumn</tt></i> and <i><tt>nextColumn</tt></i>). In left to
--   right locales, <i><tt>prevColumn</tt></i> is on the left of the
--   potential drop spot, and <i><tt>nextColumn</tt></i> is on the right.
--   In right to left mode, this is reversed. This function should return
--   <a>True</a> if the spot is a valid drop spot. Please note that
--   returning <a>True</a> does not actually indicate that the column drop
--   was made, but is meant only to indicate a possible drop spot to the
--   user.
type TreeViewColumnDropFunc_WithClosures = TreeView -> TreeViewColumn -> TreeViewColumn -> TreeViewColumn -> Ptr () -> IO Bool

-- | Function type for determining whether <i><tt>column</tt></i> can be
--   dropped in a particular spot (as determined by
--   <i><tt>prevColumn</tt></i> and <i><tt>nextColumn</tt></i>). In left to
--   right locales, <i><tt>prevColumn</tt></i> is on the left of the
--   potential drop spot, and <i><tt>nextColumn</tt></i> is on the right.
--   In right to left mode, this is reversed. This function should return
--   <a>True</a> if the spot is a valid drop spot. Please note that
--   returning <a>True</a> does not actually indicate that the column drop
--   was made, but is meant only to indicate a possible drop spot to the
--   user.
type TreeViewColumnDropFunc = TreeView -> TreeViewColumn -> TreeViewColumn -> TreeViewColumn -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_TreeViewColumnDropFunc = Ptr TreeView -> Ptr TreeViewColumn -> Ptr TreeViewColumn -> Ptr TreeViewColumn -> Ptr () -> IO CInt

-- | Function used for <a>treeViewMapExpandedRows</a>.
type TreeViewMappingFunc_WithClosures = TreeView -> TreePath -> Ptr () -> IO ()

-- | Function used for <a>treeViewMapExpandedRows</a>.
type TreeViewMappingFunc = TreeView -> TreePath -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_TreeViewMappingFunc = Ptr TreeView -> Ptr TreePath -> Ptr () -> IO ()

-- | Function type for determining whether the row pointed to by
--   <i><tt>iter</tt></i> should be rendered as a separator. A common way
--   to implement this is to have a boolean column in the model, whose
--   values the <a>TreeViewRowSeparatorFunc</a> returns.
type TreeViewRowSeparatorFunc_WithClosures = TreeModel -> TreeIter -> Ptr () -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_TreeViewRowSeparatorFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO CInt

-- | A function used for checking whether a row in <i><tt>model</tt></i>
--   matches a search key string entered by the user. Note the return value
--   is reversed from what you would normally expect, though it has some
--   similarity to <tt><i>strcmp()</i></tt> returning 0 for equal strings.
type TreeViewSearchEqualFunc_WithClosures = TreeModel -> Int32 -> Text -> TreeIter -> Ptr () -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_TreeViewSearchEqualFunc = Ptr TreeModel -> Int32 -> CString -> Ptr TreeIter -> Ptr () -> IO CInt

-- | <i>No description available in the introspection data.</i>
type TreeViewSearchPositionFunc_WithClosures = TreeView -> Widget -> Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type TreeViewSearchPositionFunc = TreeView -> Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_TreeViewSearchPositionFunc = Ptr TreeView -> Ptr Widget -> Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassAdjustBaselineAllocationFieldCallback = Widget -> Int32 -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassAdjustBaselineAllocationFieldCallback = Ptr Widget -> Int32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassAdjustBaselineRequestFieldCallback = Widget -> Int32 -> Int32 -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassAdjustBaselineRequestFieldCallback = Ptr Widget -> Int32 -> Int32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassAdjustSizeAllocationFieldCallback = Widget -> Orientation -> Int32 -> Int32 -> Int32 -> Int32 -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassAdjustSizeAllocationFieldCallback = Ptr Widget -> CUInt -> Int32 -> Int32 -> Int32 -> Int32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassAdjustSizeRequestFieldCallback = Widget -> Orientation -> Int32 -> Int32 -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassAdjustSizeRequestFieldCallback = Ptr Widget -> CUInt -> Int32 -> Int32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassButtonPressEventFieldCallback = Widget -> EventButton -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassButtonPressEventFieldCallback = Ptr Widget -> Ptr EventButton -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassButtonReleaseEventFieldCallback = Widget -> EventButton -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassButtonReleaseEventFieldCallback = Ptr Widget -> Ptr EventButton -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassCanActivateAccelFieldCallback = Widget -> Word32 -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassCanActivateAccelFieldCallback = Ptr Widget -> Word32 -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassChildNotifyFieldCallback = Widget -> GParamSpec -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassChildNotifyFieldCallback = Ptr Widget -> Ptr GParamSpec -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassCompositedChangedFieldCallback = Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassCompositedChangedFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassComputeExpandFieldCallback = Widget -> Bool -> Bool -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassComputeExpandFieldCallback = Ptr Widget -> CInt -> CInt -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassConfigureEventFieldCallback = Widget -> EventConfigure -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassConfigureEventFieldCallback = Ptr Widget -> Ptr EventConfigure -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassDamageEventFieldCallback = Widget -> EventExpose -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDamageEventFieldCallback = Ptr Widget -> Ptr EventExpose -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassDeleteEventFieldCallback = Widget -> EventAny -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDeleteEventFieldCallback = Ptr Widget -> Ptr EventAny -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassDestroyEventFieldCallback = Widget -> EventAny -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDestroyEventFieldCallback = Ptr Widget -> Ptr EventAny -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassDestroyFieldCallback = Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDestroyFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassDirectionChangedFieldCallback = Widget -> TextDirection -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDirectionChangedFieldCallback = Ptr Widget -> CUInt -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassDispatchChildPropertiesChangedFieldCallback = Widget -> Word32 -> GParamSpec -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDispatchChildPropertiesChangedFieldCallback = Ptr Widget -> Word32 -> Ptr GParamSpec -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassDragBeginFieldCallback = Widget -> DragContext -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDragBeginFieldCallback = Ptr Widget -> Ptr DragContext -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassDragDataDeleteFieldCallback = Widget -> DragContext -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDragDataDeleteFieldCallback = Ptr Widget -> Ptr DragContext -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassDragDataGetFieldCallback = Widget -> DragContext -> SelectionData -> Word32 -> Word32 -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDragDataGetFieldCallback = Ptr Widget -> Ptr DragContext -> Ptr SelectionData -> Word32 -> Word32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassDragDataReceivedFieldCallback = Widget -> DragContext -> Int32 -> Int32 -> SelectionData -> Word32 -> Word32 -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDragDataReceivedFieldCallback = Ptr Widget -> Ptr DragContext -> Int32 -> Int32 -> Ptr SelectionData -> Word32 -> Word32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassDragDropFieldCallback = Widget -> DragContext -> Int32 -> Int32 -> Word32 -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDragDropFieldCallback = Ptr Widget -> Ptr DragContext -> Int32 -> Int32 -> Word32 -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassDragEndFieldCallback = Widget -> DragContext -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDragEndFieldCallback = Ptr Widget -> Ptr DragContext -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassDragFailedFieldCallback = Widget -> DragContext -> DragResult -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDragFailedFieldCallback = Ptr Widget -> Ptr DragContext -> CUInt -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassDragLeaveFieldCallback = Widget -> DragContext -> Word32 -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDragLeaveFieldCallback = Ptr Widget -> Ptr DragContext -> Word32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassDragMotionFieldCallback = Widget -> DragContext -> Int32 -> Int32 -> Word32 -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDragMotionFieldCallback = Ptr Widget -> Ptr DragContext -> Int32 -> Int32 -> Word32 -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassDrawFieldCallback = Widget -> Context -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDrawFieldCallback = Ptr Widget -> Ptr Context -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassEnterNotifyEventFieldCallback = Widget -> EventCrossing -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassEnterNotifyEventFieldCallback = Ptr Widget -> Ptr EventCrossing -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassEventFieldCallback = Widget -> Event -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassEventFieldCallback = Ptr Widget -> Ptr Event -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassFocusFieldCallback = Widget -> DirectionType -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassFocusFieldCallback = Ptr Widget -> CUInt -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassFocusInEventFieldCallback = Widget -> EventFocus -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassFocusInEventFieldCallback = Ptr Widget -> Ptr EventFocus -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassFocusOutEventFieldCallback = Widget -> EventFocus -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassFocusOutEventFieldCallback = Ptr Widget -> Ptr EventFocus -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassGetAccessibleFieldCallback = Widget -> IO Object

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassGetAccessibleFieldCallback = Ptr Widget -> IO Ptr Object

-- | <i>No description available in the introspection data.</i>
type WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback = Widget -> Int32 -> IO (Int32, Int32, Int32, Int32)

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback = Ptr Widget -> Int32 -> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassGetPreferredHeightFieldCallback = Widget -> IO (Int32, Int32)

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassGetPreferredHeightFieldCallback = Ptr Widget -> Ptr Int32 -> Ptr Int32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassGetPreferredHeightForWidthFieldCallback = Widget -> Int32 -> IO (Int32, Int32)

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassGetPreferredHeightForWidthFieldCallback = Ptr Widget -> Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassGetPreferredWidthFieldCallback = Widget -> IO (Int32, Int32)

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassGetPreferredWidthFieldCallback = Ptr Widget -> Ptr Int32 -> Ptr Int32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassGetPreferredWidthForHeightFieldCallback = Widget -> Int32 -> IO (Int32, Int32)

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassGetPreferredWidthForHeightFieldCallback = Ptr Widget -> Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassGetRequestModeFieldCallback = Widget -> IO SizeRequestMode

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassGetRequestModeFieldCallback = Ptr Widget -> IO CUInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassGrabBrokenEventFieldCallback = Widget -> EventGrabBroken -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassGrabBrokenEventFieldCallback = Ptr Widget -> Ptr EventGrabBroken -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassGrabFocusFieldCallback = Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassGrabFocusFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassGrabNotifyFieldCallback = Widget -> Bool -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassGrabNotifyFieldCallback = Ptr Widget -> CInt -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassHideFieldCallback = Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassHideFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassHierarchyChangedFieldCallback = Widget -> Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassHierarchyChangedFieldCallback = Ptr Widget -> Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassKeyPressEventFieldCallback = Widget -> EventKey -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassKeyPressEventFieldCallback = Ptr Widget -> Ptr EventKey -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassKeyReleaseEventFieldCallback = Widget -> EventKey -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassKeyReleaseEventFieldCallback = Ptr Widget -> Ptr EventKey -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassKeynavFailedFieldCallback = Widget -> DirectionType -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassKeynavFailedFieldCallback = Ptr Widget -> CUInt -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassLeaveNotifyEventFieldCallback = Widget -> EventCrossing -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassLeaveNotifyEventFieldCallback = Ptr Widget -> Ptr EventCrossing -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassMapEventFieldCallback = Widget -> EventAny -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassMapEventFieldCallback = Ptr Widget -> Ptr EventAny -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassMapFieldCallback = Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassMapFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassMnemonicActivateFieldCallback = Widget -> Bool -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassMnemonicActivateFieldCallback = Ptr Widget -> CInt -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassMotionNotifyEventFieldCallback = Widget -> EventMotion -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassMotionNotifyEventFieldCallback = Ptr Widget -> Ptr EventMotion -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassMoveFocusFieldCallback = Widget -> DirectionType -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassMoveFocusFieldCallback = Ptr Widget -> CUInt -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassParentSetFieldCallback = Widget -> Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassParentSetFieldCallback = Ptr Widget -> Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassPopupMenuFieldCallback = Widget -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassPopupMenuFieldCallback = Ptr Widget -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassPropertyNotifyEventFieldCallback = Widget -> EventProperty -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassPropertyNotifyEventFieldCallback = Ptr Widget -> Ptr EventProperty -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassProximityInEventFieldCallback = Widget -> EventProximity -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassProximityInEventFieldCallback = Ptr Widget -> Ptr EventProximity -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassProximityOutEventFieldCallback = Widget -> EventProximity -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassProximityOutEventFieldCallback = Ptr Widget -> Ptr EventProximity -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassQueryTooltipFieldCallback = Widget -> Int32 -> Int32 -> Bool -> Tooltip -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassQueryTooltipFieldCallback = Ptr Widget -> Int32 -> Int32 -> CInt -> Ptr Tooltip -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassQueueDrawRegionFieldCallback = Widget -> Region -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassQueueDrawRegionFieldCallback = Ptr Widget -> Ptr Region -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassRealizeFieldCallback = Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassRealizeFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassScreenChangedFieldCallback = Widget -> Screen -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassScreenChangedFieldCallback = Ptr Widget -> Ptr Screen -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassScrollEventFieldCallback = Widget -> EventScroll -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassScrollEventFieldCallback = Ptr Widget -> Ptr EventScroll -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassSelectionClearEventFieldCallback = Widget -> EventSelection -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassSelectionClearEventFieldCallback = Ptr Widget -> Ptr EventSelection -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassSelectionGetFieldCallback = Widget -> SelectionData -> Word32 -> Word32 -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassSelectionGetFieldCallback = Ptr Widget -> Ptr SelectionData -> Word32 -> Word32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassSelectionNotifyEventFieldCallback = Widget -> EventSelection -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassSelectionNotifyEventFieldCallback = Ptr Widget -> Ptr EventSelection -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassSelectionReceivedFieldCallback = Widget -> SelectionData -> Word32 -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassSelectionReceivedFieldCallback = Ptr Widget -> Ptr SelectionData -> Word32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassSelectionRequestEventFieldCallback = Widget -> EventSelection -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassSelectionRequestEventFieldCallback = Ptr Widget -> Ptr EventSelection -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassShowAllFieldCallback = Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassShowAllFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassShowFieldCallback = Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassShowFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassShowHelpFieldCallback = Widget -> WidgetHelpType -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassShowHelpFieldCallback = Ptr Widget -> CUInt -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassSizeAllocateFieldCallback = Widget -> Rectangle -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassSizeAllocateFieldCallback = Ptr Widget -> Ptr Rectangle -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassStateChangedFieldCallback = Widget -> StateType -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassStateChangedFieldCallback = Ptr Widget -> CUInt -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassStateFlagsChangedFieldCallback = Widget -> [StateFlags] -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassStateFlagsChangedFieldCallback = Ptr Widget -> CUInt -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassStyleSetFieldCallback = Widget -> Style -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassStyleSetFieldCallback = Ptr Widget -> Ptr Style -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassStyleUpdatedFieldCallback = Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassStyleUpdatedFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassTouchEventFieldCallback = Widget -> EventTouch -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassTouchEventFieldCallback = Ptr Widget -> Ptr EventTouch -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassUnmapEventFieldCallback = Widget -> EventAny -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassUnmapEventFieldCallback = Ptr Widget -> Ptr EventAny -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassUnmapFieldCallback = Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassUnmapFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassUnrealizeFieldCallback = Widget -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassUnrealizeFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassVisibilityNotifyEventFieldCallback = Widget -> EventVisibility -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassVisibilityNotifyEventFieldCallback = Ptr Widget -> Ptr EventVisibility -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassWindowStateEventFieldCallback = Widget -> EventWindowState -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassWindowStateEventFieldCallback = Ptr Widget -> Ptr EventWindowState -> IO CInt

-- | This signal is emitted whenever the currently focused widget in this
--   window changes.
--   
--   <i>Since: 2.24</i>
type WindowSetFocusCallback = Maybe Widget -> IO ()

-- | The <a>keysChanged</a> signal gets emitted when the set of
--   accelerators or mnemonics that are associated with
--   <i><tt>window</tt></i> changes.
type WindowKeysChangedCallback = IO ()

-- | The <a>enableDebugging</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user enables or
--   disables interactive debugging. When <i><tt>toggle</tt></i> is
--   <a>True</a>, interactive debugging is toggled on or off, when it is
--   <a>False</a>, the debugger will be pointed at the widget under the
--   pointer.
--   
--   The default bindings for this signal are Ctrl-Shift-I and
--   Ctrl-Shift-D.
type WindowEnableDebuggingCallback = Bool -> IO Bool

-- | The <a>activateFocus</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user activates
--   the currently focused widget of <i><tt>window</tt></i>.
type WindowActivateFocusCallback = IO ()

-- | The <a>activateDefault</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user activates
--   the default widget of <i><tt>window</tt></i>.
type WindowActivateDefaultCallback = IO ()

-- | The <a>windowStateEvent</a> will be emitted when the state of the
--   toplevel window associated to the <i><tt>widget</tt></i> changes.
--   
--   To receive this signal the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_STRUCTURE_MASK</i></tt> mask. GDK will
--   enable this mask automatically for all new windows.
type WidgetWindowStateEventCallback = EventWindowState -> IO Bool

-- | The <a>visibilityNotifyEvent</a> will be emitted when the
--   <i><tt>widget</tt></i>'s window is obscured or unobscured.
--   
--   To receive this signal the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_VISIBILITY_NOTIFY_MASK</i></tt> mask.
type WidgetVisibilityNotifyEventCallback = EventVisibility -> IO Bool

-- | The <a>unrealize</a> signal is emitted when the <a>Window</a>
--   associated with <i><tt>widget</tt></i> is destroyed, which means that
--   <a>widgetUnrealize</a> has been called or the widget has been unmapped
--   (that is, it is going to be hidden).
type WidgetUnrealizeCallback = IO ()

-- | The <a>unmapEvent</a> signal will be emitted when the
--   <i><tt>widget</tt></i>'s window is unmapped. A window is unmapped when
--   it becomes invisible on the screen.
--   
--   To receive this signal, the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_STRUCTURE_MASK</i></tt> mask. GDK will
--   enable this mask automatically for all new windows.
type WidgetUnmapEventCallback = EventAny -> IO Bool

-- | The <a>unmap</a> signal is emitted when <i><tt>widget</tt></i> is
--   going to be unmapped, which means that either it or any of its parents
--   up to the toplevel widget have been set as hidden.
--   
--   As <a>unmap</a> indicates that a widget will not be shown any longer,
--   it can be used to, for example, stop an animation on the widget.
type WidgetUnmapCallback = IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetTouchEventCallback = Event -> IO Bool

-- | The <a>styleUpdated</a> signal is a convenience signal that is emitted
--   when the <a>StyleContext::changed</a> signal is emitted on the
--   <i><tt>widget</tt></i>'s associated <a>StyleContext</a> as returned by
--   <a>widgetGetStyleContext</a>.
--   
--   Note that style-modifying functions like <a>widgetOverrideColor</a>
--   also cause this signal to be emitted.
--   
--   <i>Since: 3.0</i>
type WidgetStyleUpdatedCallback = IO ()

-- | The <a>styleSet</a> signal is emitted when a new style has been set on
--   a widget. Note that style-modifying functions like
--   <a>widgetModifyBase</a> also cause this signal to be emitted.
--   
--   Note that this signal is emitted for changes to the deprecated
--   <a>Style</a>. To track changes to the <a>StyleContext</a> associated
--   with a widget, use the <a>Widget::styleUpdated</a> signal.
type WidgetStyleSetCallback = Maybe Style -> IO ()

-- | The <a>stateFlagsChanged</a> signal is emitted when the widget state
--   changes, see <a>widgetGetStateFlags</a>.
--   
--   <i>Since: 3.0</i>
type WidgetStateFlagsChangedCallback = [StateFlags] -> IO ()

-- | The <a>stateChanged</a> signal is emitted when the widget state
--   changes. See <a>widgetGetState</a>.
type WidgetStateChangedCallback = StateType -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetSizeAllocateCallback = Rectangle -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetShowHelpCallback = WidgetHelpType -> IO Bool

-- | The <a>show</a> signal is emitted when <i><tt>widget</tt></i> is
--   shown, for example with <a>widgetShow</a>.
type WidgetShowCallback = IO ()

-- | The <a>selectionRequestEvent</a> signal will be emitted when another
--   client requests ownership of the selection owned by the
--   <i><tt>widget</tt></i>'s window.
type WidgetSelectionRequestEventCallback = EventSelection -> IO Bool

-- | <i>No description available in the introspection data.</i>
type WidgetSelectionReceivedCallback = SelectionData -> Word32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetSelectionNotifyEventCallback = EventSelection -> IO Bool

-- | <i>No description available in the introspection data.</i>
type WidgetSelectionGetCallback = SelectionData -> Word32 -> Word32 -> IO ()

-- | The <a>selectionClearEvent</a> signal will be emitted when the the
--   <i><tt>widget</tt></i>'s window has lost ownership of a selection.
type WidgetSelectionClearEventCallback = EventSelection -> IO Bool

-- | The <a>scrollEvent</a> signal is emitted when a button in the 4 to 7
--   range is pressed. Wheel mice are usually configured to generate button
--   press events for buttons 4 and 5 when the wheel is turned.
--   
--   To receive this signal, the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_SCROLL_MASK</i></tt> mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetScrollEventCallback = EventScroll -> IO Bool

-- | The <a>screenChanged</a> signal gets emitted when the screen of a
--   widget has changed.
type WidgetScreenChangedCallback = Maybe Screen -> IO ()

-- | The <a>realize</a> signal is emitted when <i><tt>widget</tt></i> is
--   associated with a <a>Window</a>, which means that <a>widgetRealize</a>
--   has been called or the widget has been mapped (that is, it is going to
--   be drawn).
type WidgetRealizeCallback = IO ()

-- | Emitted when <a>Widget:hasTooltip</a> is <a>True</a> and the hover
--   timeout has expired with the cursor hovering "above"
--   <i><tt>widget</tt></i>; or emitted when <i><tt>widget</tt></i> got
--   focus in keyboard mode.
--   
--   Using the given coordinates, the signal handler should determine
--   whether a tooltip should be shown for <i><tt>widget</tt></i>. If this
--   is the case <a>True</a> should be returned, <a>False</a> otherwise.
--   Note that if <i><tt>keyboardMode</tt></i> is <a>True</a>, the values
--   of <i><tt>x</tt></i> and <i><tt>y</tt></i> are undefined and should
--   not be used.
--   
--   The signal handler is free to manipulate <i><tt>tooltip</tt></i> with
--   the therefore destined function calls.
--   
--   <i>Since: 2.12</i>
type WidgetQueryTooltipCallback = Int32 -> Int32 -> Bool -> Tooltip -> IO Bool

-- | To receive this signal the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_PROXIMITY_OUT_MASK</i></tt> mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetProximityOutEventCallback = EventProximity -> IO Bool

-- | To receive this signal the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_PROXIMITY_IN_MASK</i></tt> mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetProximityInEventCallback = EventProximity -> IO Bool

-- | The <a>propertyNotifyEvent</a> signal will be emitted when a property
--   on the <i><tt>widget</tt></i>'s window has been changed or deleted.
--   
--   To receive this signal, the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_PROPERTY_CHANGE_MASK</i></tt> mask.
type WidgetPropertyNotifyEventCallback = EventProperty -> IO Bool

-- | This signal gets emitted whenever a widget should pop up a context
--   menu. This usually happens through the standard key binding mechanism;
--   by pressing a certain key while a widget is focused, the user can
--   cause the widget to pop up a menu. For example, the <a>Entry</a>
--   widget creates a menu with clipboard commands. See the [Popup Menu
--   Migration Checklist][checklist-popup-menu] for an example of how to
--   use this signal.
type WidgetPopupMenuCallback = IO Bool

-- | The <a>parentSet</a> signal is emitted when a new parent has been set
--   on a widget.
type WidgetParentSetCallback = Maybe Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetMoveFocusCallback = DirectionType -> IO ()

-- | The <a>motionNotifyEvent</a> signal is emitted when the pointer moves
--   over the widget's <a>Window</a>.
--   
--   To receive this signal, the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_POINTER_MOTION_MASK</i></tt> mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetMotionNotifyEventCallback = EventMotion -> IO Bool

-- | The default handler for this signal activates <i><tt>widget</tt></i>
--   if <i><tt>groupCycling</tt></i> is <a>False</a>, or just makes
--   <i><tt>widget</tt></i> grab focus if <i><tt>groupCycling</tt></i> is
--   <a>True</a>.
type WidgetMnemonicActivateCallback = Bool -> IO Bool

-- | The <a>mapEvent</a> signal will be emitted when the
--   <i><tt>widget</tt></i>'s window is mapped. A window is mapped when it
--   becomes visible on the screen.
--   
--   To receive this signal, the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_STRUCTURE_MASK</i></tt> mask. GDK will
--   enable this mask automatically for all new windows.
type WidgetMapEventCallback = EventAny -> IO Bool

-- | The <a>map</a> signal is emitted when <i><tt>widget</tt></i> is going
--   to be mapped, that is when the widget is visible (which is controlled
--   with <a>widgetSetVisible</a>) and all its parents up to the toplevel
--   widget are also visible. Once the map has occurred,
--   <a>Widget::mapEvent</a> will be emitted.
--   
--   The <a>map</a> signal can be used to determine whether a widget will
--   be drawn, for instance it can resume an animation that was stopped
--   during the emission of <a>Widget::unmap</a>.
type WidgetMapCallback = IO ()

-- | The <a>leaveNotifyEvent</a> will be emitted when the pointer leaves
--   the <i><tt>widget</tt></i>'s window.
--   
--   To receive this signal, the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_LEAVE_NOTIFY_MASK</i></tt> mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetLeaveNotifyEventCallback = EventCrossing -> IO Bool

-- | Gets emitted if keyboard navigation fails. See
--   <a>widgetKeynavFailed</a> for details.
--   
--   <i>Since: 2.12</i>
type WidgetKeynavFailedCallback = DirectionType -> IO Bool

-- | The <a>keyReleaseEvent</a> signal is emitted when a key is released.
--   
--   To receive this signal, the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_KEY_RELEASE_MASK</i></tt> mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetKeyReleaseEventCallback = EventKey -> IO Bool

-- | The <a>keyPressEvent</a> signal is emitted when a key is pressed. The
--   signal emission will reoccur at the key-repeat rate when the key is
--   kept pressed.
--   
--   To receive this signal, the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_KEY_PRESS_MASK</i></tt> mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetKeyPressEventCallback = EventKey -> IO Bool

-- | The <a>hierarchyChanged</a> signal is emitted when the anchored state
--   of a widget changes. A widget is “anchored” when its toplevel ancestor
--   is a <a>Window</a>. This signal is emitted when a widget changes from
--   un-anchored to anchored or vice-versa.
type WidgetHierarchyChangedCallback = Maybe Widget -> IO ()

-- | The <a>hide</a> signal is emitted when <i><tt>widget</tt></i> is
--   hidden, for example with <a>widgetHide</a>.
type WidgetHideCallback = IO ()

-- | The <a>grabNotify</a> signal is emitted when a widget becomes shadowed
--   by a GTK+ grab (not a pointer or keyboard grab) on another widget, or
--   when it becomes unshadowed due to a grab being removed.
--   
--   A widget is shadowed by a <a>widgetGrabAdd</a> when the topmost grab
--   widget in the grab stack of its window group is not its ancestor.
type WidgetGrabNotifyCallback = Bool -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetGrabFocusCallback = IO ()

-- | Emitted when a pointer or keyboard grab on a window belonging to
--   <i><tt>widget</tt></i> gets broken.
--   
--   On X11, this happens when the grab window becomes unviewable (i.e. it
--   or one of its ancestors is unmapped), or if the same application grabs
--   the pointer or keyboard again.
--   
--   <i>Since: 2.8</i>
type WidgetGrabBrokenEventCallback = EventGrabBroken -> IO Bool

-- | The <a>focusOutEvent</a> signal will be emitted when the keyboard
--   focus leaves the <i><tt>widget</tt></i>'s window.
--   
--   To receive this signal, the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_FOCUS_CHANGE_MASK</i></tt> mask.
type WidgetFocusOutEventCallback = EventFocus -> IO Bool

-- | The <a>focusInEvent</a> signal will be emitted when the keyboard focus
--   enters the <i><tt>widget</tt></i>'s window.
--   
--   To receive this signal, the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_FOCUS_CHANGE_MASK</i></tt> mask.
type WidgetFocusInEventCallback = EventFocus -> IO Bool

-- | <i>No description available in the introspection data.</i>
type WidgetFocusCallback = DirectionType -> IO Bool

-- | After the emission of the <a>Widget::event</a> signal and (optionally)
--   the second more specific signal, <a>eventAfter</a> will be emitted
--   regardless of the previous two signals handlers return values.
type WidgetEventAfterCallback = Event -> IO ()

-- | The GTK+ main loop will emit three signals for each GDK event
--   delivered to a widget: one generic <a>event</a> signal, another, more
--   specific, signal that matches the type of event delivered (e.g.
--   <a>Widget::keyPressEvent</a>) and finally a generic
--   <a>Widget::eventAfter</a> signal.
type WidgetEventCallback = Event -> IO Bool

-- | The <a>enterNotifyEvent</a> will be emitted when the pointer enters
--   the <i><tt>widget</tt></i>'s window.
--   
--   To receive this signal, the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_ENTER_NOTIFY_MASK</i></tt> mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetEnterNotifyEventCallback = EventCrossing -> IO Bool

-- | This signal is emitted when a widget is supposed to render itself. The
--   <i><tt>widget</tt></i>'s top left corner must be painted at the origin
--   of the passed in context and be sized to the values returned by
--   <a>widgetGetAllocatedWidth</a> and <a>widgetGetAllocatedHeight</a>.
--   
--   Signal handlers connected to this signal can modify the cairo context
--   passed as <i><tt>cr</tt></i> in any way they like and don't need to
--   restore it. The signal emission takes care of calling
--   <tt><i>cairo_save()</i></tt> before and
--   <tt><i>cairo_restore()</i></tt> after invoking the handler.
--   
--   The signal handler will get a <i><tt>cr</tt></i> with a clip region
--   already set to the widget's dirty region, i.e. to the area that needs
--   repainting. Complicated widgets that want to avoid redrawing
--   themselves completely can get the full extents of the clip region with
--   <a>cairoGetClipRectangle</a>, or they can get a finer-grained
--   representation of the dirty region with
--   <tt><i>cairo_copy_clip_rectangle_list()</i></tt>.
--   
--   <i>Since: 3.0</i>
type WidgetDrawCallback = Context -> IO Bool

-- | The <a>dragMotion</a> signal is emitted on the drop site when the user
--   moves the cursor over the widget during a drag. The signal handler
--   must determine whether the cursor position is in a drop zone or not.
--   If it is not in a drop zone, it returns <a>False</a> and no further
--   processing is necessary. Otherwise, the handler returns <a>True</a>.
--   In this case, the handler is responsible for providing the necessary
--   information for displaying feedback to the user, by calling
--   <a>dragStatus</a>.
--   
--   If the decision whether the drop will be accepted or rejected can't be
--   made based solely on the cursor position and the type of the data, the
--   handler may inspect the dragged data by calling
--   <a>widgetDragGetData</a> and defer the <a>dragStatus</a> call to the
--   <a>Widget::dragDataReceived</a> handler. Note that you must pass
--   <tt><i>GTK_DEST_DEFAULT_DROP</i></tt>,
--   <tt><i>GTK_DEST_DEFAULT_MOTION</i></tt> or
--   <tt><i>GTK_DEST_DEFAULT_ALL</i></tt> to <a>widgetDragDestSet</a> when
--   using the drag-motion signal that way.
--   
--   Also note that there is no drag-enter signal. The drag receiver has to
--   keep track of whether he has received any drag-motion signals since
--   the last <a>Widget::dragLeave</a> and if not, treat the drag-motion
--   signal as an "enter" signal. Upon an "enter", the handler will
--   typically highlight the drop site with <a>widgetDragHighlight</a>.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   static void
--   drag_motion (GtkWidget      *widget,
--                GdkDragContext *context,
--                gint            x,
--                gint            y,
--                guint           time)
--   {
--     GdkAtom target;
--   
--     PrivateData *private_data = GET_PRIVATE_DATA (widget);
--   
--     if (!private_data-&gt;drag_highlight)
--      {
--        private_data-&gt;drag_highlight = 1;
--        gtk_drag_highlight (widget);
--      }
--   
--     target = gtk_drag_dest_find_target (widget, context, NULL);
--     if (target == GDK_NONE)
--       gdk_drag_status (context, 0, time);
--     else
--      {
--        private_data-&gt;pending_status
--           = gdk_drag_context_get_suggested_action (context);
--        gtk_drag_get_data (widget, context, target, time);
--      }
--   
--     return TRUE;
--   }
--   
--   static void
--   drag_data_received (GtkWidget        *widget,
--                       GdkDragContext   *context,
--                       gint              x,
--                       gint              y,
--                       GtkSelectionData *selection_data,
--                       guint             info,
--                       guint             time)
--   {
--     PrivateData *private_data = GET_PRIVATE_DATA (widget);
--   
--     if (private_data-&gt;suggested_action)
--      {
--        private_data-&gt;suggested_action = 0;
--   
--        // We are getting this data due to a request in drag_motion,
--        // rather than due to a request in drag_drop, so we are just
--        // supposed to call gdk_drag_status(), not actually paste in
--        // the data.
--   
--        str = gtk_selection_data_get_text (selection_data);
--        if (!data_is_acceptable (str))
--          gdk_drag_status (context, 0, time);
--        else
--          gdk_drag_status (context,
--                           private_data-&gt;suggested_action,
--                           time);
--      }
--     else
--      {
--        // accept the drop
--      }
--   }
--   </pre>
type WidgetDragMotionCallback = DragContext -> Int32 -> Int32 -> Word32 -> IO Bool

-- | The <a>dragLeave</a> signal is emitted on the drop site when the
--   cursor leaves the widget. A typical reason to connect to this signal
--   is to undo things done in <a>Widget::dragMotion</a>, e.g. undo
--   highlighting with <a>widgetDragUnhighlight</a>.
--   
--   Likewise, the <a>Widget::dragLeave</a> signal is also emitted before
--   the <a>dragDrop</a> signal, for instance to allow cleaning up of a
--   preview item created in the <a>Widget::dragMotion</a> signal handler.
type WidgetDragLeaveCallback = DragContext -> Word32 -> IO ()

-- | The <a>dragFailed</a> signal is emitted on the drag source when a drag
--   has failed. The signal handler may hook custom code to handle a failed
--   DnD operation based on the type of error, it returns <a>True</a> is
--   the failure has been already handled (not showing the default "drag
--   operation failed" animation), otherwise it returns <a>False</a>.
--   
--   <i>Since: 2.12</i>
type WidgetDragFailedCallback = DragContext -> DragResult -> IO Bool

-- | The <a>dragEnd</a> signal is emitted on the drag source when a drag is
--   finished. A typical reason to connect to this signal is to undo things
--   done in <a>Widget::dragBegin</a>.
type WidgetDragEndCallback = DragContext -> IO ()

-- | The <a>dragDrop</a> signal is emitted on the drop site when the user
--   drops the data onto the widget. The signal handler must determine
--   whether the cursor position is in a drop zone or not. If it is not in
--   a drop zone, it returns <a>False</a> and no further processing is
--   necessary. Otherwise, the handler returns <a>True</a>. In this case,
--   the handler must ensure that <a>dragFinish</a> is called to let the
--   source know that the drop is done. The call to <a>dragFinish</a> can
--   be done either directly or in a <a>Widget::dragDataReceived</a>
--   handler which gets triggered by calling <a>widgetDragGetData</a> to
--   receive the data for one or more of the supported targets.
type WidgetDragDropCallback = DragContext -> Int32 -> Int32 -> Word32 -> IO Bool

-- | The <a>dragDataReceived</a> signal is emitted on the drop site when
--   the dragged data has been received. If the data was received in order
--   to determine whether the drop will be accepted, the handler is
--   expected to call <a>dragStatus</a> and not finish the drag. If the
--   data was received in response to a <a>Widget::dragDrop</a> signal (and
--   this is the last target to be received), the handler for this signal
--   is expected to process the received data and then call
--   <a>dragFinish</a>, setting the <i><tt>success</tt></i> parameter
--   depending on whether the data was processed successfully.
--   
--   Applications must create some means to determine why the signal was
--   emitted and therefore whether to call <a>dragStatus</a> or
--   <a>dragFinish</a>.
--   
--   The handler may inspect the selected action with
--   <a>dragContextGetSelectedAction</a> before calling <a>dragFinish</a>,
--   e.g. to implement <a>DragActionAsk</a> as shown in the following
--   example:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   void
--   drag_data_received (GtkWidget          *widget,
--                       GdkDragContext     *context,
--                       gint                x,
--                       gint                y,
--                       GtkSelectionData   *data,
--                       guint               info,
--                       guint               time)
--   {
--     if ((data-&gt;length &gt;= 0) &amp;&amp; (data-&gt;format == 8))
--       {
--         GdkDragAction action;
--   
--         // handle data here
--   
--         action = gdk_drag_context_get_selected_action (context);
--         if (action == GDK_ACTION_ASK)
--           {
--             GtkWidget *dialog;
--             gint response;
--   
--             dialog = gtk_message_dialog_new (NULL,
--                                              GTK_DIALOG_MODAL |
--                                              GTK_DIALOG_DESTROY_WITH_PARENT,
--                                              GTK_MESSAGE_INFO,
--                                              GTK_BUTTONS_YES_NO,
--                                              "Move the data ?\n");
--             response = gtk_dialog_run (GTK_DIALOG (dialog));
--             gtk_widget_destroy (dialog);
--   
--             if (response == GTK_RESPONSE_YES)
--               action = GDK_ACTION_MOVE;
--             else
--               action = GDK_ACTION_COPY;
--            }
--   
--         gtk_drag_finish (context, TRUE, action == GDK_ACTION_MOVE, time);
--       }
--     else
--       gtk_drag_finish (context, FALSE, FALSE, time);
--    }
--   </pre>
type WidgetDragDataReceivedCallback = DragContext -> Int32 -> Int32 -> SelectionData -> Word32 -> Word32 -> IO ()

-- | The <a>dragDataGet</a> signal is emitted on the drag source when the
--   drop site requests the data which is dragged. It is the responsibility
--   of the signal handler to fill <i><tt>data</tt></i> with the data in
--   the format which is indicated by <i><tt>info</tt></i>. See
--   <a>selectionDataSet</a> and <a>selectionDataSetText</a>.
type WidgetDragDataGetCallback = DragContext -> SelectionData -> Word32 -> Word32 -> IO ()

-- | The <a>dragDataDelete</a> signal is emitted on the drag source when a
--   drag with the action <a>DragActionMove</a> is successfully completed.
--   The signal handler is responsible for deleting the data that has been
--   dropped. What "delete" means depends on the context of the drag
--   operation.
type WidgetDragDataDeleteCallback = DragContext -> IO ()

-- | The <a>dragBegin</a> signal is emitted on the drag source when a drag
--   is started. A typical reason to connect to this signal is to set up a
--   custom drag icon with e.g. <a>widgetDragSourceSetIconPixbuf</a>.
--   
--   Note that some widgets set up a drag icon in the default handler of
--   this signal, so you may have to use
--   <tt><i>g_signal_connect_after()</i></tt> to override what the default
--   handler did.
type WidgetDragBeginCallback = DragContext -> IO ()

-- | The <a>directionChanged</a> signal is emitted when the text direction
--   of a widget changes.
type WidgetDirectionChangedCallback = TextDirection -> IO ()

-- | The <a>destroyEvent</a> signal is emitted when a <a>Window</a> is
--   destroyed. You rarely get this signal, because most widgets disconnect
--   themselves from their window before they destroy it, so no widget owns
--   the window at destroy time.
--   
--   To receive this signal, the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_STRUCTURE_MASK</i></tt> mask. GDK will
--   enable this mask automatically for all new windows.
type WidgetDestroyEventCallback = Event -> IO Bool

-- | Signals that all holders of a reference to the widget should release
--   the reference that they hold. May result in finalization of the widget
--   if all references are released.
--   
--   This signal is not suitable for saving widget state.
type WidgetDestroyCallback = IO ()

-- | The <a>deleteEvent</a> signal is emitted if a user requests that a
--   toplevel window is closed. The default handler for this signal
--   destroys the window. Connecting <a>widgetHideOnDelete</a> to this
--   signal will cause the window to be hidden instead, so that it can
--   later be shown again without reconstructing it.
type WidgetDeleteEventCallback = Event -> IO Bool

-- | Emitted when a redirected window belonging to <i><tt>widget</tt></i>
--   gets drawn into. The region/area members of the event shows what area
--   of the redirected drawable was drawn into.
--   
--   <i>Since: 2.14</i>
type WidgetDamageEventCallback = EventExpose -> IO Bool

-- | The <a>configureEvent</a> signal will be emitted when the size,
--   position or stacking of the <i><tt>widget</tt></i>'s window has
--   changed.
--   
--   To receive this signal, the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_STRUCTURE_MASK</i></tt> mask. GDK will
--   enable this mask automatically for all new windows.
type WidgetConfigureEventCallback = EventConfigure -> IO Bool

-- | The <a>compositedChanged</a> signal is emitted when the composited
--   status of <i><tt>widgets</tt></i> screen changes. See
--   <a>screenIsComposited</a>.
type WidgetCompositedChangedCallback = IO ()

-- | The <a>childNotify</a> signal is emitted for each [child
--   property][child-properties] that has changed on an object. The
--   signal's detail holds the property name.
type WidgetChildNotifyCallback = GParamSpec -> IO ()

-- | Determines whether an accelerator that activates the signal identified
--   by <i><tt>signalId</tt></i> can currently be activated. This signal is
--   present to allow applications and derived widgets to override the
--   default <a>Widget</a> handling for determining whether an accelerator
--   can be activated.
type WidgetCanActivateAccelCallback = Word32 -> IO Bool

-- | The <a>buttonReleaseEvent</a> signal will be emitted when a button
--   (typically from a mouse) is released.
--   
--   To receive this signal, the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_BUTTON_RELEASE_MASK</i></tt> mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetButtonReleaseEventCallback = EventButton -> IO Bool

-- | The <a>buttonPressEvent</a> signal will be emitted when a button
--   (typically from a mouse) is pressed.
--   
--   To receive this signal, the <a>Window</a> associated to the widget
--   needs to enable the <tt><i>GDK_BUTTON_PRESS_MASK</i></tt> mask.
--   
--   This signal will be sent to the grab widget if there is one.
type WidgetButtonPressEventCallback = EventButton -> IO Bool

-- | <i>No description available in the introspection data.</i>
type WidgetAccelClosuresChangedCallback = IO ()

-- | <i>No description available in the introspection data.</i>
type TextTagTableTagRemovedCallback = TextTag -> IO ()

-- | <i>No description available in the introspection data.</i>
type TextTagTableTagChangedCallback = TextTag -> Bool -> IO ()

-- | <i>No description available in the introspection data.</i>
type TextTagTableTagAddedCallback = TextTag -> IO ()

-- | The <a>event</a> signal is emitted when an event occurs on a region of
--   the buffer marked with this tag.
type TextTagEventCallback = Object -> Event -> TextIter -> IO Bool

-- | The <a>removeTag</a> signal is emitted to remove all occurrences of
--   <i><tt>tag</tt></i> from a range of text in a <a>TextBuffer</a>.
--   Removal actually occurs in the default handler.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the <i><tt>start</tt></i> and <i><tt>end</tt></i> iters (or
--   has to revalidate them).
--   
--   See also: <a>textBufferRemoveTag</a>.
type TextBufferRemoveTagCallback = TextTag -> TextIter -> TextIter -> IO ()

-- | The paste-done signal is emitted after paste operation has been
--   completed. This is useful to properly scroll the view to the end of
--   the pasted text. See <a>textBufferPasteClipboard</a> for more details.
--   
--   <i>Since: 2.16</i>
type TextBufferPasteDoneCallback = Clipboard -> IO ()

-- | The <a>modifiedChanged</a> signal is emitted when the modified bit of
--   a <a>TextBuffer</a> flips.
--   
--   See also: <a>textBufferSetModified</a>.
type TextBufferModifiedChangedCallback = IO ()

-- | The <a>markSet</a> signal is emitted as notification after a
--   <a>TextMark</a> is set.
--   
--   See also: <a>textBufferCreateMark</a>, <a>textBufferMoveMark</a>.
type TextBufferMarkSetCallback = TextIter -> TextMark -> IO ()

-- | The <a>markDeleted</a> signal is emitted as notification after a
--   <a>TextMark</a> is deleted.
--   
--   See also: <a>textBufferDeleteMark</a>.
type TextBufferMarkDeletedCallback = TextMark -> IO ()

-- | The <a>insertText</a> signal is emitted to insert text in a
--   <a>TextBuffer</a>. Insertion actually occurs in the default handler.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the <i><tt>location</tt></i> iter (or has to revalidate
--   it). The default signal handler revalidates it to point to the end of
--   the inserted text.
--   
--   See also: <a>textBufferInsert</a>, <a>textBufferInsertRange</a>.
type TextBufferInsertTextCallback = TextIter -> Text -> Int32 -> IO ()

-- | The <a>insertPixbuf</a> signal is emitted to insert a <a>Pixbuf</a> in
--   a <a>TextBuffer</a>. Insertion actually occurs in the default handler.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the <i><tt>location</tt></i> iter (or has to revalidate
--   it). The default signal handler revalidates it to be placed after the
--   inserted <i><tt>pixbuf</tt></i>.
--   
--   See also: <a>textBufferInsertPixbuf</a>.
type TextBufferInsertPixbufCallback = TextIter -> Pixbuf -> IO ()

-- | The <a>insertChildAnchor</a> signal is emitted to insert a
--   <a>TextChildAnchor</a> in a <a>TextBuffer</a>. Insertion actually
--   occurs in the default handler.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the <i><tt>location</tt></i> iter (or has to revalidate
--   it). The default signal handler revalidates it to be placed after the
--   inserted <i><tt>anchor</tt></i>.
--   
--   See also: <a>textBufferInsertChildAnchor</a>.
type TextBufferInsertChildAnchorCallback = TextIter -> TextChildAnchor -> IO ()

-- | The <a>endUserAction</a> signal is emitted at the end of a single
--   user-visible operation on the <a>TextBuffer</a>.
--   
--   See also: <a>textBufferEndUserAction</a>,
--   <a>textBufferInsertInteractive</a>,
--   <a>textBufferInsertRangeInteractive</a>,
--   <a>textBufferDeleteInteractive</a>, <a>textBufferBackspace</a>,
--   <a>textBufferDeleteSelection</a>, <a>textBufferBackspace</a>.
type TextBufferEndUserActionCallback = IO ()

-- | The <a>deleteRange</a> signal is emitted to delete a range from a
--   <a>TextBuffer</a>.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the <i><tt>start</tt></i> and <i><tt>end</tt></i> iters (or
--   has to revalidate them). The default signal handler revalidates the
--   <i><tt>start</tt></i> and <i><tt>end</tt></i> iters to both point to
--   the location where text was deleted. Handlers which run after the
--   default handler (see <tt><i>g_signal_connect_after()</i></tt>) do not
--   have access to the deleted text.
--   
--   See also: <a>textBufferDelete</a>.
type TextBufferDeleteRangeCallback = TextIter -> TextIter -> IO ()

-- | The <a>changed</a> signal is emitted when the content of a
--   <a>TextBuffer</a> has changed.
type TextBufferChangedCallback = IO ()

-- | The <a>beginUserAction</a> signal is emitted at the beginning of a
--   single user-visible operation on a <a>TextBuffer</a>.
--   
--   See also: <a>textBufferBeginUserAction</a>,
--   <a>textBufferInsertInteractive</a>,
--   <a>textBufferInsertRangeInteractive</a>,
--   <a>textBufferDeleteInteractive</a>, <a>textBufferBackspace</a>,
--   <a>textBufferDeleteSelection</a>.
type TextBufferBeginUserActionCallback = IO ()

-- | The <a>applyTag</a> signal is emitted to apply a tag to a range of
--   text in a <a>TextBuffer</a>. Applying actually occurs in the default
--   handler.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the <i><tt>start</tt></i> and <i><tt>end</tt></i> iters (or
--   has to revalidate them).
--   
--   See also: <a>textBufferApplyTag</a>,
--   <tt><i>gtk_text_buffer_insert_with_tags()</i></tt>,
--   <a>textBufferInsertRange</a>.
type TextBufferApplyTagCallback = TextTag -> TextIter -> TextIter -> IO ()

-- | The <a>changed</a> signal is emitted when there is a change in the
--   <a>StyleContext</a>.
--   
--   For a <a>StyleContext</a> returned by <a>widgetGetStyleContext</a>,
--   the <a>Widget::styleUpdated</a> signal/vfunc might be more convenient
--   to use.
--   
--   This signal is useful when using the theming layer standalone.
--   
--   <i>Since: 3.0</i>
type StyleContextChangedCallback = IO ()

-- | Emitted when the aspects of the style specific to a particular visual
--   is being cleaned up. A connection to this signal can be useful if a
--   widget wants to cache objects as object data on <a>Style</a>. This
--   signal provides a convenient place to free such cached objects.
--   
--   <i>Since: 2.4</i>
type StyleUnrealizeCallback = IO ()

-- | Emitted when the style has been initialized for a particular visual.
--   Connecting to this signal is probably seldom useful since most of the
--   time applications and widgets only deal with styles that have been
--   already realized.
--   
--   <i>Since: 2.4</i>
type StyleRealizeCallback = IO ()

-- | <i>No description available in the introspection data.</i>
type ContainerSetFocusChildCallback = Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type ContainerRemoveCallback = Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type ContainerCheckResizeCallback = IO ()

-- | <i>No description available in the introspection data.</i>
type ContainerAddCallback = Widget -> IO ()

-- | The <a>ownerChange</a> signal is emitted when GTK+ receives an event
--   that indicates that the ownership of the selection associated with
--   <i><tt>clipboard</tt></i> has changed.
--   
--   <i>Since: 2.6</i>
type ClipboardOwnerChangeCallback = EventOwnerChange -> IO ()

-- | Emitted when a <a>Window</a> is removed from
--   <i><tt>application</tt></i>, either as a side-effect of being
--   destroyed or explicitly through <a>applicationRemoveWindow</a>.
--   
--   <i>Since: 3.2</i>
type ApplicationWindowRemovedCallback = Window -> IO ()

-- | Emitted when a <a>Window</a> is added to <i><tt>application</tt></i>
--   through <a>applicationAddWindow</a>.
--   
--   <i>Since: 3.2</i>
type ApplicationWindowAddedCallback = Window -> IO ()

-- | Emitted when the session manager is about to end the session, only if
--   <a>Application</a>::<tt><i>register-session</i></tt> is <a>True</a>.
--   Applications can connect to this signal and call
--   <a>applicationInhibit</a> with <a>ApplicationInhibitFlagsLogout</a> to
--   delay the end of the session until state has been saved.
--   
--   <i>Since: 3.24.8</i>
type ApplicationQueryEndCallback = IO ()

-- | The accel-changed signal is emitted when an entry is added to or
--   removed from the accel group.
--   
--   Widgets like <a>AccelLabel</a> which display an associated accelerator
--   should connect to this signal, and rebuild their visual representation
--   if the <i><tt>accelClosure</tt></i> is theirs.
type AccelGroupAccelChangedCallback = Word32 -> [ModifierType] -> GClosure () -> IO ()

-- | The accel-activate signal is an implementation detail of
--   <a>AccelGroup</a> and not meant to be used by applications.
type AccelGroupAccelActivateCallback = Object -> Word32 -> [ModifierType] -> IO Bool

-- | This signal is emitted when a new row has been inserted in the model.
--   
--   Note that the row may still be empty at this point, since it is a
--   common pattern to first insert an empty row, and then fill it with the
--   desired values.
type TreeModelRowInsertedCallback = TreePath -> TreeIter -> IO ()

-- | This signal is emitted when a row has gotten the first child row or
--   lost its last child row.
type TreeModelRowHasChildToggledCallback = TreePath -> TreeIter -> IO ()

-- | This signal is emitted when a row has been deleted.
--   
--   Note that no iterator is passed to the signal handler, since the row
--   is already deleted.
--   
--   This should be called by models after a row has been removed. The
--   location pointed to by <i><tt>path</tt></i> should be the location
--   that the row previously was at. It may not be a valid location
--   anymore.
type TreeModelRowDeletedCallback = TreePath -> IO ()

-- | This signal is emitted when a row in the model has changed.
type TreeModelRowChangedCallback = TreePath -> TreeIter -> IO ()

-- | <i>No description available in the introspection data.</i>
type TreeViewColumnClickedCallback = IO ()

-- | This signal gets emitted when a cell starts to be edited. The intended
--   use of this signal is to do special setup on <i><tt>editable</tt></i>,
--   e.g. adding a <a>EntryCompletion</a> or setting up additional columns
--   in a <a>ComboBox</a>.
--   
--   See <a>cellEditableStartEditing</a> for information on the lifecycle
--   of the <i><tt>editable</tt></i> and a way to do setup that doesn’t
--   depend on the <i><tt>renderer</tt></i>.
--   
--   Note that GTK+ doesn't guarantee that cell renderers will continue to
--   use the same kind of widget for editing in future releases, therefore
--   you should check the type of <i><tt>editable</tt></i> before doing any
--   specific setup, as in the following example:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   static void
--   text_editing_started (GtkCellRenderer *cell,
--                         GtkCellEditable *editable,
--                         const gchar     *path,
--                         gpointer         data)
--   {
--     if (GTK_IS_ENTRY (editable))
--       {
--         GtkEntry *entry = GTK_ENTRY (editable);
--         
--         // ... create a GtkEntryCompletion
--         
--         gtk_entry_set_completion (entry, completion);
--       }
--   }
--   </pre>
--   
--   <i>Since: 2.6</i>
type CellRendererEditingStartedCallback = CellEditable -> Text -> IO ()

-- | This signal gets emitted when the user cancels the process of editing
--   a cell. For example, an editable cell renderer could be written to
--   cancel editing when the user presses Escape.
--   
--   See also: <a>cellRendererStopEditing</a>.
--   
--   <i>Since: 2.4</i>
type CellRendererEditingCanceledCallback = IO ()

-- | This signal is meant to indicate that the cell is finished editing,
--   and the <i><tt>cellEditable</tt></i> widget is being removed and may
--   subsequently be destroyed.
--   
--   Implementations of <a>CellEditable</a> are responsible for emitting
--   this signal when they are done editing. It must be emitted after the
--   <a>CellEditable::editingDone</a> signal, to give the cell renderer a
--   chance to update the cell's value before the widget is removed.
--   
--   <a>cellEditableRemoveWidget</a> is a convenience method for emitting
--   <a>CellEditable::removeWidget</a>.
type CellEditableRemoveWidgetCallback = IO ()

-- | This signal is a sign for the cell renderer to update its value from
--   the <i><tt>cellEditable</tt></i>.
--   
--   Implementations of <a>CellEditable</a> are responsible for emitting
--   this signal when they are done editing, e.g. <a>Entry</a> emits this
--   signal when the user presses Enter. Typical things to do in a handler
--   for <a>editingDone</a> are to capture the edited value, disconnect the
--   <i><tt>cellEditable</tt></i> from signals on the <a>CellRenderer</a>,
--   etc.
--   
--   <a>cellEditableEditingDone</a> is a convenience method for emitting
--   <a>CellEditable::editingDone</a>.
type CellEditableEditingDoneCallback = IO ()

-- | Indicates that editing finished on <i><tt>renderer</tt></i> and that
--   <i><tt>editable</tt></i> should be removed from the owning
--   cell-layouting widget.
--   
--   <i>Since: 3.0</i>
type CellAreaRemoveEditableCallback = CellRenderer -> CellEditable -> IO ()

-- | Indicates that focus changed on this <i><tt>area</tt></i>. This signal
--   is emitted either as a result of focus handling or event handling.
--   
--   It's possible that the signal is emitted even if the currently focused
--   renderer did not change, this is because focus may change to the same
--   renderer in the same cell area for a different row of data.
--   
--   <i>Since: 3.0</i>
type CellAreaFocusChangedCallback = CellRenderer -> Text -> IO ()

-- | This signal is emitted whenever applying attributes to
--   <i><tt>area</tt></i> from <i><tt>model</tt></i>
--   
--   <i>Since: 3.0</i>
type CellAreaApplyAttributesCallback = TreeModel -> TreeIter -> Bool -> Bool -> IO ()

-- | Indicates that editing has started on <i><tt>renderer</tt></i> and
--   that <i><tt>editable</tt></i> should be added to the owning
--   cell-layouting widget at <i><tt>cellArea</tt></i>.
--   
--   <i>Since: 3.0</i>
type CellAreaAddEditableCallback = CellRenderer -> CellEditable -> Rectangle -> Text -> IO ()

-- | <i>No description available in the introspection data.</i>
type TreeViewUnselectAllCallback = IO Bool

-- | <i>No description available in the introspection data.</i>
type TreeViewToggleCursorRowCallback = IO Bool

-- | The given row is about to be expanded (show its children nodes). Use
--   this signal if you need to control the expandability of individual
--   rows.
type TreeViewTestExpandRowCallback = TreeIter -> TreePath -> IO Bool

-- | The given row is about to be collapsed (hide its children nodes). Use
--   this signal if you need to control the collapsibility of individual
--   rows.
type TreeViewTestCollapseRowCallback = TreeIter -> TreePath -> IO Bool

-- | <i>No description available in the introspection data.</i>
type TreeViewStartInteractiveSearchCallback = IO Bool

-- | <i>No description available in the introspection data.</i>
type TreeViewSelectCursorRowCallback = Bool -> IO Bool

-- | <i>No description available in the introspection data.</i>
type TreeViewSelectCursorParentCallback = IO Bool

-- | <i>No description available in the introspection data.</i>
type TreeViewSelectAllCallback = IO Bool

-- | The given row has been expanded (child nodes are shown).
type TreeViewRowExpandedCallback = TreeIter -> TreePath -> IO ()

-- | The given row has been collapsed (child nodes are hidden).
type TreeViewRowCollapsedCallback = TreeIter -> TreePath -> IO ()

-- | The "row-activated" signal is emitted when the method
--   <a>treeViewRowActivated</a> is called, when the user double clicks a
--   treeview row with the "activate-on-single-click" property set to
--   <a>False</a>, or when the user single clicks a row when the
--   "activate-on-single-click" property set to <a>True</a>. It is also
--   emitted when a non-editable row is selected and one of the keys:
--   Space, Shift+Space, Return or Enter is pressed.
--   
--   For selection handling refer to the <a>tree widget conceptual
--   overview</a> as well as <a>TreeSelection</a>.
type TreeViewRowActivatedCallback = TreePath -> TreeViewColumn -> IO ()

-- | The <a>TreeView::moveCursor</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user presses one
--   of the cursor keys.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control the
--   cursor programmatically. In contrast to <a>treeViewSetCursor</a> and
--   <a>treeViewSetCursorOnCell</a> when moving horizontally
--   <a>TreeView::moveCursor</a> does not reset the current selection.
type TreeViewMoveCursorCallback = MovementStep -> Int32 -> IO Bool

-- | <i>No description available in the introspection data.</i>
type TreeViewExpandCollapseCursorRowCallback = Bool -> Bool -> Bool -> IO Bool

-- | The position of the cursor (focused cell) has changed.
type TreeViewCursorChangedCallback = IO ()

-- | The number of columns of the treeview has changed.
type TreeViewColumnsChangedCallback = IO ()

-- | Emitted whenever the selection has (possibly) changed. Please note
--   that this signal is mostly a hint. It may only be emitted once when a
--   range of rows are selected, and it may occasionally be emitted when
--   nothing has happened.
type TreeSelectionChangedCallback = IO ()

-- | Gets emitted when the filter model has zero number of rows in
--   completion_complete method. (In other words when GtkEntryCompletion is
--   out of suggestions)
--   
--   <i>Since: 3.14</i>
type EntryCompletionNoMatchesCallback = IO ()

-- | Gets emitted when a match from the list is selected. The default
--   behaviour is to replace the contents of the entry with the contents of
--   the text column in the row pointed to by <i><tt>iter</tt></i>.
--   
--   Note that <i><tt>model</tt></i> is the model that was passed to
--   <a>entryCompletionSetModel</a>.
--   
--   <i>Since: 2.4</i>
type EntryCompletionMatchSelectedCallback = TreeModel -> TreeIter -> IO Bool

-- | Gets emitted when the inline autocompletion is triggered. The default
--   behaviour is to make the entry display the whole prefix and select the
--   newly inserted part.
--   
--   Applications may connect to this signal in order to insert only a
--   smaller part of the <i><tt>prefix</tt></i> into the entry - e.g. the
--   entry used in the <a>FileChooser</a> inserts only the part of the
--   prefix up to the next '/'.
--   
--   <i>Since: 2.6</i>
type EntryCompletionInsertPrefixCallback = Text -> IO Bool

-- | Gets emitted when a match from the cursor is on a match of the list.
--   The default behaviour is to replace the contents of the entry with the
--   contents of the text column in the row pointed to by
--   <i><tt>iter</tt></i>.
--   
--   Note that <i><tt>model</tt></i> is the model that was passed to
--   <a>entryCompletionSetModel</a>.
--   
--   <i>Since: 2.12</i>
type EntryCompletionCursorOnMatchCallback = TreeModel -> TreeIter -> IO Bool

-- | Gets emitted when an action is activated.
--   
--   <i>Since: 2.4</i>
type EntryCompletionActionActivatedCallback = Int32 -> IO ()

-- | The <a>toggleOverwrite</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to toggle the overwrite
--   mode of the entry.
--   
--   The default bindings for this signal is Insert.
type EntryToggleOverwriteCallback = IO ()

-- | If an input method is used, the typed text will not immediately be
--   committed to the buffer. So if you are interested in the text, connect
--   to this signal.
--   
--   <i>Since: 2.20</i>
type EntryPreeditChangedCallback = Text -> IO ()

-- | The <a>populatePopup</a> signal gets emitted before showing the
--   context menu of the entry.
--   
--   If you need to add items to the context menu, connect to this signal
--   and append your items to the <i><tt>widget</tt></i>, which will be a
--   <a>Menu</a> in this case.
--   
--   If <a>Entry:populateAll</a> is <a>True</a>, this signal will also be
--   emitted to populate touch popups. In this case, <i><tt>widget</tt></i>
--   will be a different container, e.g. a <a>Toolbar</a>. The signal
--   handler should not make assumptions about the type of
--   <i><tt>widget</tt></i>.
type EntryPopulatePopupCallback = Widget -> IO ()

-- | The <a>pasteClipboard</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to paste the contents of
--   the clipboard into the text view.
--   
--   The default bindings for this signal are Ctrl-v and Shift-Insert.
type EntryPasteClipboardCallback = IO ()

-- | The <a>moveCursor</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user initiates a
--   cursor movement. If the cursor is not visible in
--   <i><tt>entry</tt></i>, this signal causes the viewport to be moved
--   instead.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control the
--   cursor programmatically.
--   
--   The default bindings for this signal come in two variants, the variant
--   with the Shift modifier extends the selection, the variant without the
--   Shift modifer does not. There are too many key combinations to list
--   them all here.
--   
--   <ul>
--   <li>Arrow keys move by individual characters/lines</li>
--   <li>Ctrl-arrow key combinations move by words/paragraphs</li>
--   <li>Home/End keys move to the ends of the buffer</li>
--   </ul>
type EntryMoveCursorCallback = MovementStep -> Int32 -> Bool -> IO ()

-- | The <a>insertEmoji</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to present the Emoji
--   chooser for the <i><tt>entry</tt></i>.
--   
--   The default bindings for this signal are Ctrl-. and Ctrl-;
--   
--   <i>Since: 3.22.27</i>
type EntryInsertEmojiCallback = IO ()

-- | The <a>insertAtCursor</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user initiates
--   the insertion of a fixed string at the cursor.
--   
--   This signal has no default bindings.
type EntryInsertAtCursorCallback = Text -> IO ()

-- | The <a>iconRelease</a> signal is emitted on the button release from a
--   mouse click over an activatable icon.
--   
--   <i>Since: 2.16</i>
type EntryIconReleaseCallback = EntryIconPosition -> Event -> IO ()

-- | The <a>iconPress</a> signal is emitted when an activatable icon is
--   clicked.
--   
--   <i>Since: 2.16</i>
type EntryIconPressCallback = EntryIconPosition -> Event -> IO ()

-- | The <a>deleteFromCursor</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user initiates a
--   text deletion.
--   
--   If the <i><tt>type</tt></i> is <a>DeleteTypeChars</a>, GTK+ deletes
--   the selection if there is one, otherwise it deletes the requested
--   number of characters.
--   
--   The default bindings for this signal are Delete for deleting a
--   character and Ctrl-Delete for deleting a word.
type EntryDeleteFromCursorCallback = DeleteType -> Int32 -> IO ()

-- | The <a>cutClipboard</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to cut the selection to
--   the clipboard.
--   
--   The default bindings for this signal are Ctrl-x and Shift-Delete.
type EntryCutClipboardCallback = IO ()

-- | The <a>copyClipboard</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to copy the selection to
--   the clipboard.
--   
--   The default bindings for this signal are Ctrl-c and Ctrl-Insert.
type EntryCopyClipboardCallback = IO ()

-- | The <a>backspace</a> signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted when the user asks for it.
--   
--   The default bindings for this signal are Backspace and
--   Shift-Backspace.
type EntryBackspaceCallback = IO ()

-- | The <a>activate</a> signal is emitted when the user hits the Enter
--   key.
--   
--   While this signal is used as a [keybinding signal][GtkBindingSignal],
--   it is also commonly used by applications to intercept activation of
--   entries.
--   
--   The default bindings for this signal are all forms of the Enter key.
type EntryActivateCallback = IO ()

-- | This signal is emitted when a selection has been completed within a
--   menu shell.
type MenuShellSelectionDoneCallback = IO ()

-- | The <a>moveSelected</a> signal is emitted to move the selection to
--   another item.
--   
--   <i>Since: 2.12</i>
type MenuShellMoveSelectedCallback = Int32 -> IO Bool

-- | An keybinding signal which moves the current menu item in the
--   direction specified by <i><tt>direction</tt></i>.
type MenuShellMoveCurrentCallback = MenuDirectionType -> IO ()

-- | The <a>insert</a> signal is emitted when a new <a>MenuItem</a> is
--   added to a <a>MenuShell</a>. A separate signal is used instead of
--   GtkContainer<a>add</a> because of the need for an additional position
--   parameter.
--   
--   The inverse of this signal is the GtkContainer<a>removed</a> signal.
--   
--   <i>Since: 3.2</i>
type MenuShellInsertCallback = Widget -> Int32 -> IO ()

-- | This signal is emitted when a menu shell is deactivated.
type MenuShellDeactivateCallback = IO ()

-- | A keybinding signal which moves the focus in the given
--   <i><tt>direction</tt></i>.
type MenuShellCycleFocusCallback = DirectionType -> IO ()

-- | An action signal which cancels the selection within the menu shell.
--   Causes the <a>MenuShell::selectionDone</a> signal to be emitted.
type MenuShellCancelCallback = IO ()

-- | An action signal that activates the current menu item within the menu
--   shell.
type MenuShellActivateCurrentCallback = Bool -> IO ()

-- | <i>No description available in the introspection data.</i>
type MenuItemToggleSizeRequestCallback = Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type MenuItemToggleSizeAllocateCallback = Int32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type MenuItemSelectCallback = IO ()

-- | <i>No description available in the introspection data.</i>
type MenuItemDeselectCallback = IO ()

-- | Emitted when the item is activated, but also if the menu item has a
--   submenu. For normal applications, the relevant signal is
--   <a>MenuItem::activate</a>.
type MenuItemActivateItemCallback = IO ()

-- | Emitted when the item is activated.
type MenuItemActivateCallback = IO ()

-- | Emitted when the position of <i><tt>menu</tt></i> is finalized after
--   being popped up using gtk_menu_popup_at_rect (),
--   gtk_menu_popup_at_widget (), or gtk_menu_popup_at_pointer ().
--   
--   <i><tt>menu</tt></i> might be flipped over the anchor rectangle in
--   order to keep it on-screen, in which case <i><tt>flippedX</tt></i> and
--   <i><tt>flippedY</tt></i> will be set to <a>True</a> accordingly.
--   
--   <i><tt>flippedRect</tt></i> is the ideal position of
--   <i><tt>menu</tt></i> after any possible flipping, but before any
--   possible sliding. <i><tt>finalRect</tt></i> is
--   <i><tt>flippedRect</tt></i>, but possibly translated in the case that
--   flipping is still ineffective in keeping <i><tt>menu</tt></i>
--   on-screen.
--   
--   
--   The blue menu is <i><tt>menu</tt></i>'s ideal position, the green menu
--   is <i><tt>flippedRect</tt></i>, and the red menu is
--   <i><tt>finalRect</tt></i>.
--   
--   See gtk_menu_popup_at_rect (), gtk_menu_popup_at_widget (),
--   gtk_menu_popup_at_pointer (), <a>Menu:anchorHints</a>,
--   <a>Menu:rectAnchorDx</a>, <a>Menu:rectAnchorDy</a>, and
--   <a>Menu:menuTypeHint</a>.
--   
--   <i>Since: 3.22</i>
type MenuPoppedUpCallback = Ptr () -> Ptr () -> Bool -> Bool -> IO ()

-- | <i>No description available in the introspection data.</i>
type MenuMoveScrollCallback = ScrollType -> IO ()

-- | The <a>preActivate</a> signal is emitted just before the
--   <i><tt>action</tt></i> in the <i><tt>actionGroup</tt></i> is activated
--   
--   This is intended for <a>UIManager</a> to proxy the signal and provide
--   global notification just before any action is activated.
--   
--   <i>Since: 2.4</i>
type ActionGroupPreActivateCallback = Action -> IO ()

-- | The <a>postActivate</a> signal is emitted just after the
--   <i><tt>action</tt></i> in the <i><tt>actionGroup</tt></i> is activated
--   
--   This is intended for <a>UIManager</a> to proxy the signal and provide
--   global notification just after any action is activated.
--   
--   <i>Since: 2.4</i>
type ActionGroupPostActivateCallback = Action -> IO ()

-- | The <a>disconnectProxy</a> signal is emitted after disconnecting a
--   proxy from an action in the group.
--   
--   <a>UIManager</a> proxies the signal and provides global notification
--   just before any action is connected to a proxy, which is probably more
--   convenient to use.
--   
--   <i>Since: 2.4</i>
type ActionGroupDisconnectProxyCallback = Action -> Widget -> IO ()

-- | The <a>connectProxy</a> signal is emitted after connecting a proxy to
--   an action in the group. Note that the proxy may have been connected to
--   a different action before.
--   
--   This is intended for simple customizations for which a custom action
--   class would be too clumsy, e.g. showing tooltips for menuitems in the
--   statusbar.
--   
--   <a>UIManager</a> proxies the signal and provides global notification
--   just before any action is connected to a proxy, which is probably more
--   convenient to use.
--   
--   <i>Since: 2.4</i>
type ActionGroupConnectProxyCallback = Action -> Widget -> IO ()

-- | The "activate" signal is emitted when the action is activated.
--   
--   <i>Since: 2.4</i>
type ActionActivateCallback = IO ()

-- | This is a keybinding signal, which will cause this row to be
--   activated.
--   
--   If you want to be notified when the user activates a row (by key or
--   not), use the <a>ListBox::rowActivated</a> signal on the row’s parent
--   <a>ListBox</a>.
--   
--   <i>Since: 3.10</i>
type ListBoxRowActivateCallback = IO ()

-- | The <a>unselectAll</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to unselect all children
--   of the box, if the selection mode permits it.
--   
--   The default bindings for this signal is Ctrl-Shift-a.
--   
--   <i>Since: 3.14</i>
type ListBoxUnselectAllCallback = IO ()

-- | <i>No description available in the introspection data.</i>
type ListBoxToggleCursorRowCallback = IO ()

-- | The <a>selectedRowsChanged</a> signal is emitted when the set of
--   selected rows changes.
--   
--   <i>Since: 3.14</i>
type ListBoxSelectedRowsChangedCallback = IO ()

-- | The <a>selectAll</a> signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted to select all children of the box, if the selection
--   mode permits it.
--   
--   The default bindings for this signal is Ctrl-a.
--   
--   <i>Since: 3.14</i>
type ListBoxSelectAllCallback = IO ()

-- | The <a>rowSelected</a> signal is emitted when a new row is selected,
--   or (with a <a>Nothing</a> <i><tt>row</tt></i>) when the selection is
--   cleared.
--   
--   When the <i><tt>box</tt></i> is using
--   <tt><i>GTK_SELECTION_MULTIPLE</i></tt>, this signal will not give you
--   the full picture of selection changes, and you should use the
--   <a>ListBox::selectedRowsChanged</a> signal instead.
--   
--   <i>Since: 3.10</i>
type ListBoxRowSelectedCallback = Maybe ListBoxRow -> IO ()

-- | The <a>rowActivated</a> signal is emitted when a row has been
--   activated by the user.
--   
--   <i>Since: 3.10</i>
type ListBoxRowActivatedCallback = ListBoxRow -> IO ()

-- | <i>No description available in the introspection data.</i>
type ListBoxMoveCursorCallback = MovementStep -> Int32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type ListBoxActivateCursorRowCallback = IO ()

-- | A [keybinding signal][GtkBindingSignal] which gets emitted when the
--   user unselects all items.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control
--   selection programmatically.
--   
--   The default binding for this signal is Ctrl-Shift-a.
type IconViewUnselectAllCallback = IO ()

-- | A [keybinding signal][GtkBindingSignal] which gets emitted when the
--   user toggles whether the currently focused item is selected or not.
--   The exact effect of this depend on the selection mode.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control
--   selection programmatically.
--   
--   There is no default binding for this signal is Ctrl-Space.
type IconViewToggleCursorItemCallback = IO ()

-- | The <a>selectionChanged</a> signal is emitted when the selection (i.e.
--   the set of selected items) changes.
type IconViewSelectionChangedCallback = IO ()

-- | A [keybinding signal][GtkBindingSignal] which gets emitted when the
--   user selects the item that is currently focused.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control
--   selection programmatically.
--   
--   There is no default binding for this signal.
type IconViewSelectCursorItemCallback = IO ()

-- | A [keybinding signal][GtkBindingSignal] which gets emitted when the
--   user selects all items.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control
--   selection programmatically.
--   
--   The default binding for this signal is Ctrl-a.
type IconViewSelectAllCallback = IO ()

-- | The <a>moveCursor</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user initiates a
--   cursor movement.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control the
--   cursor programmatically.
--   
--   The default bindings for this signal include
--   
--   <ul>
--   <li>Arrow keys which move by individual steps</li>
--   <li>Home/End keys which move to the first/last item</li>
--   <li>PageUp/PageDown which move by "pages"</li>
--   </ul>
--   
--   All of these will extend the selection when combined with the Shift
--   modifier.
type IconViewMoveCursorCallback = MovementStep -> Int32 -> IO Bool

-- | The <a>itemActivated</a> signal is emitted when the method
--   <a>iconViewItemActivated</a> is called, when the user double clicks an
--   item with the "activate-on-single-click" property set to <a>False</a>,
--   or when the user single clicks an item when the
--   "activate-on-single-click" property set to <a>True</a>. It is also
--   emitted when a non-editable item is selected and one of the keys:
--   Space, Return or Enter is pressed.
type IconViewItemActivatedCallback = TreePath -> IO ()

-- | A [keybinding signal][GtkBindingSignal] which gets emitted when the
--   user activates the currently focused item.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control
--   activation programmatically.
--   
--   The default bindings for this signal are Space, Return and Enter.
type IconViewActivateCursorItemCallback = IO Bool

-- | The <a>activate</a> signal is emitted when the user activates a child
--   widget in a <a>FlowBox</a>, either by clicking or double-clicking, or
--   by using the Space or Enter key.
--   
--   While this signal is used as a [keybinding signal][GtkBindingSignal],
--   it can be used by applications for their own purposes.
type FlowBoxChildActivateCallback = IO ()

-- | The <a>unselectAll</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to unselect all children
--   of the box, if the selection mode permits it.
--   
--   The default bindings for this signal is Ctrl-Shift-a.
type FlowBoxUnselectAllCallback = IO ()

-- | The <a>toggleCursorChild</a> signal is a [keybinding
--   signal][GtkBindingSignal] which toggles the selection of the child
--   that has the focus.
--   
--   The default binding for this signal is Ctrl-Space.
type FlowBoxToggleCursorChildCallback = IO ()

-- | The <a>selectedChildrenChanged</a> signal is emitted when the set of
--   selected children changes.
--   
--   Use <a>flowBoxSelectedForeach</a> or <a>flowBoxGetSelectedChildren</a>
--   to obtain the selected children.
type FlowBoxSelectedChildrenChangedCallback = IO ()

-- | The <a>selectAll</a> signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted to select all children of the box, if the selection
--   mode permits it.
--   
--   The default bindings for this signal is Ctrl-a.
type FlowBoxSelectAllCallback = IO ()

-- | The <a>moveCursor</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user initiates a
--   cursor movement.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control the
--   cursor programmatically.
--   
--   The default bindings for this signal come in two variants, the variant
--   with the Shift modifier extends the selection, the variant without the
--   Shift modifer does not. There are too many key combinations to list
--   them all here.
--   
--   <ul>
--   <li>Arrow keys move by individual children</li>
--   <li>Home/End keys move to the ends of the box</li>
--   <li>PageUp/PageDown keys move vertically by pages</li>
--   </ul>
type FlowBoxMoveCursorCallback = MovementStep -> Int32 -> IO Bool

-- | The <a>childActivated</a> signal is emitted when a child has been
--   activated by the user.
type FlowBoxChildActivatedCallback = FlowBoxChild -> IO ()

-- | The <a>activateCursorChild</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user activates
--   the <i><tt>box</tt></i>.
type FlowBoxActivateCursorChildCallback = IO ()

-- | Emitted when user switched to the previous year.
type CalendarPrevYearCallback = IO ()

-- | Emitted when the user switched to the previous month.
type CalendarPrevMonthCallback = IO ()

-- | Emitted when user switched to the next year.
type CalendarNextYearCallback = IO ()

-- | Emitted when the user switched to the next month.
type CalendarNextMonthCallback = IO ()

-- | Emitted when the user clicks a button to change the selected month on
--   a calendar.
type CalendarMonthChangedCallback = IO ()

-- | Emitted when the user double-clicks a day.
type CalendarDaySelectedDoubleClickCallback = IO ()

-- | Emitted when the user selects a day.
type CalendarDaySelectedCallback = IO ()

-- | Memory-managed wrapper type.
newtype () => WidgetClass
WidgetClass :: ManagedPtr WidgetClass -> WidgetClass

-- | Memory-managed wrapper type.
newtype () => ActionableInterface
ActionableInterface :: ManagedPtr ActionableInterface -> ActionableInterface

-- | Type class for types which can be safely cast to <a>PrintSettings</a>,
--   for instance with <a>toPrintSettings</a>.
class (GObject o, IsDescendantOf PrintSettings o) => IsPrintSettings o

-- | Type class for types which can be safely cast to <a>AccelMap</a>, for
--   instance with <a>toAccelMap</a>.
class (GObject o, IsDescendantOf AccelMap o) => IsAccelMap o

-- | Memory-managed wrapper type.
newtype () => AccelMap
AccelMap :: ManagedPtr AccelMap -> AccelMap

-- | Notifies of a change in the global accelerator map. The path is also
--   used as the detail for the signal, so it is possible to connect to
--   changed::<tt>accel_path</tt>.
--   
--   <i>Since: 2.4</i>
type AccelMapChangedCallback = Text -> Word32 -> [ModifierType] -> IO ()

-- | Memory-managed wrapper type.
newtype () => TreeRowReference
TreeRowReference :: ManagedPtr TreeRowReference -> TreeRowReference

-- | Type class for types which can be safely cast to <a>TreeSortable</a>,
--   for instance with <a>toTreeSortable</a>.
class (GObject o, IsDescendantOf TreeSortable o) => IsTreeSortable o

-- | The <a>sortColumnChanged</a> signal is emitted when the sort column or
--   sort order of <i><tt>sortable</tt></i> is changed. The signal is
--   emitted before the contents of <i><tt>sortable</tt></i> are resorted.
type TreeSortableSortColumnChangedCallback = IO ()

-- | Type class for types which can be safely cast to <a>FontChooser</a>,
--   for instance with <a>toFontChooser</a>.
class (GObject o, IsDescendantOf FontChooser o) => IsFontChooser o

-- | Emitted when a font is activated. This usually happens when the user
--   double clicks an item, or an item is selected and the user presses one
--   of the keys Space, Shift+Space, Return or Enter.
type FontChooserFontActivatedCallback = Text -> IO ()

-- | Memory-managed wrapper type.
newtype () => TableChild
TableChild :: ManagedPtr TableChild -> TableChild

-- | Memory-managed wrapper type.
newtype () => Gradient
Gradient :: ManagedPtr Gradient -> Gradient

-- | Memory-managed wrapper type.
newtype () => FixedChild
FixedChild :: ManagedPtr FixedChild -> FixedChild

-- | Type class for types which can be safely cast to <a>Viewport</a>, for
--   instance with <a>toViewport</a>.
class (GObject o, IsDescendantOf Viewport o) => IsViewport o

-- | Type class for types which can be safely cast to
--   <a>ToplevelAccessible</a>, for instance with
--   <a>toToplevelAccessible</a>.
class (GObject o, IsDescendantOf ToplevelAccessible o) => IsToplevelAccessible o

-- | Memory-managed wrapper type.
newtype () => ToplevelAccessible
ToplevelAccessible :: ManagedPtr ToplevelAccessible -> ToplevelAccessible

-- | Type class for types which can be safely cast to <a>ThemingEngine</a>,
--   for instance with <a>toThemingEngine</a>.
class (GObject o, IsDescendantOf ThemingEngine o) => IsThemingEngine o

-- | Memory-managed wrapper type.
newtype () => ThemingEngine
ThemingEngine :: ManagedPtr ThemingEngine -> ThemingEngine

-- | Type class for types which can be safely cast to <a>TextView</a>, for
--   instance with <a>toTextView</a>.
class (GObject o, IsDescendantOf TextView o) => IsTextView o

-- | The <a>toggleOverwrite</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to toggle the overwrite
--   mode of the text view.
--   
--   The default bindings for this signal is Insert.
type TextViewToggleOverwriteCallback = IO ()

-- | The <a>toggleCursorVisible</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to toggle the
--   <a>TextView:cursorVisible</a> property.
--   
--   The default binding for this signal is F7.
type TextViewToggleCursorVisibleCallback = IO ()

-- | The <a>setAnchor</a> signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted when the user initiates setting the "anchor" mark.
--   The "anchor" mark gets placed at the same position as the "insert"
--   mark.
--   
--   This signal has no default bindings.
type TextViewSetAnchorCallback = IO ()

-- | The <a>selectAll</a> signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted to select or unselect the complete contents of the
--   text view.
--   
--   The default bindings for this signal are Ctrl-a and Ctrl-/ for
--   selecting and Shift-Ctrl-a and Ctrl-\ for unselecting.
type TextViewSelectAllCallback = Bool -> IO ()

-- | If an input method is used, the typed text will not immediately be
--   committed to the buffer. So if you are interested in the text, connect
--   to this signal.
--   
--   This signal is only emitted if the text at the given position is
--   actually editable.
--   
--   <i>Since: 2.20</i>
type TextViewPreeditChangedCallback = Text -> IO ()

-- | The <a>populatePopup</a> signal gets emitted before showing the
--   context menu of the text view.
--   
--   If you need to add items to the context menu, connect to this signal
--   and append your items to the <i><tt>popup</tt></i>, which will be a
--   <a>Menu</a> in this case.
--   
--   If <a>TextView:populateAll</a> is <a>True</a>, this signal will also
--   be emitted to populate touch popups. In this case,
--   <i><tt>popup</tt></i> will be a different container, e.g. a
--   <a>Toolbar</a>.
--   
--   The signal handler should not make assumptions about the type of
--   <i><tt>widget</tt></i>, but check whether <i><tt>popup</tt></i> is a
--   <a>Menu</a> or <a>Toolbar</a> or another kind of container.
type TextViewPopulatePopupCallback = Widget -> IO ()

-- | The <a>pasteClipboard</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to paste the contents of
--   the clipboard into the text view.
--   
--   The default bindings for this signal are Ctrl-v and Shift-Insert.
type TextViewPasteClipboardCallback = IO ()

-- | The <a>moveViewport</a> signal is a [keybinding
--   signal][GtkBindingSignal] which can be bound to key combinations to
--   allow the user to move the viewport, i.e. change what part of the text
--   view is visible in a containing scrolled window.
--   
--   There are no default bindings for this signal.
type TextViewMoveViewportCallback = ScrollStep -> Int32 -> IO ()

-- | The <a>moveCursor</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user initiates a
--   cursor movement. If the cursor is not visible in
--   <i><tt>textView</tt></i>, this signal causes the viewport to be moved
--   instead.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control the
--   cursor programmatically.
--   
--   The default bindings for this signal come in two variants, the variant
--   with the Shift modifier extends the selection, the variant without the
--   Shift modifer does not. There are too many key combinations to list
--   them all here.
--   
--   <ul>
--   <li>Arrow keys move by individual characters/lines</li>
--   <li>Ctrl-arrow key combinations move by words/paragraphs</li>
--   <li>Home/End keys move to the ends of the buffer</li>
--   <li>PageUp/PageDown keys move vertically by pages</li>
--   <li>Ctrl-PageUp/PageDown keys move horizontally by pages</li>
--   </ul>
type TextViewMoveCursorCallback = MovementStep -> Int32 -> Bool -> IO ()

-- | The <a>insertEmoji</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to present the Emoji
--   chooser for the <i><tt>textView</tt></i>.
--   
--   The default bindings for this signal are Ctrl-. and Ctrl-;
--   
--   <i>Since: 3.22.27</i>
type TextViewInsertEmojiCallback = IO ()

-- | The <a>insertAtCursor</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user initiates
--   the insertion of a fixed string at the cursor.
--   
--   This signal has no default bindings.
type TextViewInsertAtCursorCallback = Text -> IO ()

-- | The <a>extendSelection</a> signal is emitted when the selection needs
--   to be extended at <i><tt>location</tt></i>.
--   
--   <i>Since: 3.16</i>
type TextViewExtendSelectionCallback = TextExtendSelection -> TextIter -> TextIter -> TextIter -> IO Bool

-- | The <a>deleteFromCursor</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user initiates a
--   text deletion.
--   
--   If the <i><tt>type</tt></i> is <a>DeleteTypeChars</a>, GTK+ deletes
--   the selection if there is one, otherwise it deletes the requested
--   number of characters.
--   
--   The default bindings for this signal are Delete for deleting a
--   character, Ctrl-Delete for deleting a word and Ctrl-Backspace for
--   deleting a word backwords.
type TextViewDeleteFromCursorCallback = DeleteType -> Int32 -> IO ()

-- | The <a>cutClipboard</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to cut the selection to
--   the clipboard.
--   
--   The default bindings for this signal are Ctrl-x and Shift-Delete.
type TextViewCutClipboardCallback = IO ()

-- | The <a>copyClipboard</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to copy the selection to
--   the clipboard.
--   
--   The default bindings for this signal are Ctrl-c and Ctrl-Insert.
type TextViewCopyClipboardCallback = IO ()

-- | The <a>backspace</a> signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted when the user asks for it.
--   
--   The default bindings for this signal are Backspace and
--   Shift-Backspace.
type TextViewBackspaceCallback = IO ()

-- | Type class for types which can be safely cast to <a>Table</a>, for
--   instance with <a>toTable</a>.
class (GObject o, IsDescendantOf Table o) => IsTable o

-- | Type class for types which can be safely cast to <a>Stack</a>, for
--   instance with <a>toStack</a>.
class (GObject o, IsDescendantOf Stack o) => IsStack o

-- | Type class for types which can be safely cast to <a>StackSidebar</a>,
--   for instance with <a>toStackSidebar</a>.
class (GObject o, IsDescendantOf StackSidebar o) => IsStackSidebar o

-- | Memory-managed wrapper type.
newtype () => StackSidebar
StackSidebar :: ManagedPtr StackSidebar -> StackSidebar

-- | Type class for types which can be safely cast to <a>Spinner</a>, for
--   instance with <a>toSpinner</a>.
class (GObject o, IsDescendantOf Spinner o) => IsSpinner o

-- | Type class for types which can be safely cast to <a>Socket</a>, for
--   instance with <a>toSocket</a>.
class (GObject o, IsDescendantOf Socket o) => IsSocket o

-- | This signal is emitted when a client is removed from the socket. The
--   default action is to destroy the <a>Socket</a> widget, so if you want
--   to reuse it you must add a signal handler that returns <a>True</a>.
type SocketPlugRemovedCallback = IO Bool

-- | This signal is emitted when a client is successfully added to the
--   socket.
type SocketPlugAddedCallback = IO ()

-- | Type class for types which can be safely cast to <a>SizeGroup</a>, for
--   instance with <a>toSizeGroup</a>.
class (GObject o, IsDescendantOf SizeGroup o) => IsSizeGroup o

-- | Type class for types which can be safely cast to
--   <a>ShortcutsWindow</a>, for instance with <a>toShortcutsWindow</a>.
class (GObject o, IsDescendantOf ShortcutsWindow o) => IsShortcutsWindow o

-- | The <a>search</a> signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted when the user uses a keybinding to start a search.
--   
--   The default binding for this signal is Control-F.
type ShortcutsWindowSearchCallback = IO ()

-- | The <a>close</a> signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted when the user uses a keybinding to close the
--   window.
--   
--   The default binding for this signal is the Escape key.
type ShortcutsWindowCloseCallback = IO ()

-- | Type class for types which can be safely cast to <a>Separator</a>, for
--   instance with <a>toSeparator</a>.
class (GObject o, IsDescendantOf Separator o) => IsSeparator o

-- | Type class for types which can be safely cast to <a>VSeparator</a>,
--   for instance with <a>toVSeparator</a>.
class (GObject o, IsDescendantOf VSeparator o) => IsVSeparator o

-- | Memory-managed wrapper type.
newtype () => VSeparator
VSeparator :: ManagedPtr VSeparator -> VSeparator

-- | Type class for types which can be safely cast to
--   <a>ScrolledWindow</a>, for instance with <a>toScrolledWindow</a>.
class (GObject o, IsDescendantOf ScrolledWindow o) => IsScrolledWindow o

-- | The <a>scrollChild</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when a keybinding that
--   scrolls is pressed. The horizontal or vertical adjustment is updated
--   which triggers a signal that the scrolled window’s child may listen to
--   and scroll itself.
type ScrolledWindowScrollChildCallback = ScrollType -> Bool -> IO Bool

-- | The <a>moveFocusOut</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when focus is moved away
--   from the scrolled window by a keybinding. The <a>Widget::moveFocus</a>
--   signal is emitted with <i><tt>directionType</tt></i> on this scrolled
--   window’s toplevel parent in the container hierarchy. The default
--   bindings for this signal are <tt>Ctrl + Tab</tt> to move forward and
--   <tt>Ctrl + Shift + Tab</tt> to move backward.
type ScrolledWindowMoveFocusOutCallback = DirectionType -> IO ()

-- | The <a>edgeReached</a> signal is emitted whenever user-initiated
--   scrolling makes the scrolled window exactly reach the lower or upper
--   limits defined by the adjustment in that orientation.
--   
--   A similar behavior with edge resistance is provided by the
--   <a>ScrolledWindow::edgeOvershot</a> signal.
--   
--   Note: The <i><tt>pos</tt></i> argument is LTR/RTL aware, so callers
--   should be aware too if intending to provide behavior on horizontal
--   edges.
--   
--   <i>Since: 3.16</i>
type ScrolledWindowEdgeReachedCallback = PositionType -> IO ()

-- | The <a>edgeOvershot</a> signal is emitted whenever user initiated
--   scrolling makes the scrolled window firmly surpass (i.e. with some
--   edge resistance) the lower or upper limits defined by the adjustment
--   in that orientation.
--   
--   A similar behavior without edge resistance is provided by the
--   <a>ScrolledWindow::edgeReached</a> signal.
--   
--   Note: The <i><tt>pos</tt></i> argument is LTR/RTL aware, so callers
--   should be aware too if intending to provide behavior on horizontal
--   edges.
--   
--   <i>Since: 3.16</i>
type ScrolledWindowEdgeOvershotCallback = PositionType -> IO ()

-- | Type class for types which can be safely cast to <a>Revealer</a>, for
--   instance with <a>toRevealer</a>.
class (GObject o, IsDescendantOf Revealer o) => IsRevealer o

-- | Type class for types which can be safely cast to <a>RecentFilter</a>,
--   for instance with <a>toRecentFilter</a>.
class (GObject o, IsDescendantOf RecentFilter o) => IsRecentFilter o

-- | Type class for types which can be safely cast to <a>Range</a>, for
--   instance with <a>toRange</a>.
class (GObject o, IsDescendantOf Range o) => IsRange o

-- | Memory-managed wrapper type.
newtype () => Range
Range :: ManagedPtr Range -> Range

-- | Emitted when the range value changes.
type RangeValueChangedCallback = IO ()

-- | Virtual function that moves the slider. Used for keybindings.
type RangeMoveSliderCallback = ScrollType -> IO ()

-- | The <a>Range::changeValue</a> signal is emitted when a scroll action
--   is performed on a range. It allows an application to determine the
--   type of scroll event that occurred and the resultant new value. The
--   application can handle the event itself and return <a>True</a> to
--   prevent further processing. Or, by returning <a>False</a>, it can pass
--   the event to other handlers until the default GTK+ handler is reached.
--   
--   The value parameter is unrounded. An application that overrides the
--   GtkRange<a>changeValue</a> signal is responsible for clamping the
--   value to the desired number of decimal digits; the default GTK+
--   handler clamps the value based on <a>Range:roundDigits</a>.
--   
--   <i>Since: 2.6</i>
type RangeChangeValueCallback = ScrollType -> Double -> IO Bool

-- | Emitted before clamping a value, to give the application a chance to
--   adjust the bounds.
type RangeAdjustBoundsCallback = Double -> IO ()

-- | Type class for types which can be safely cast to <a>Scrollbar</a>, for
--   instance with <a>toScrollbar</a>.
class (GObject o, IsDescendantOf Scrollbar o) => IsScrollbar o

-- | Type class for types which can be safely cast to <a>VScrollbar</a>,
--   for instance with <a>toVScrollbar</a>.
class (GObject o, IsDescendantOf VScrollbar o) => IsVScrollbar o

-- | Memory-managed wrapper type.
newtype () => VScrollbar
VScrollbar :: ManagedPtr VScrollbar -> VScrollbar

-- | Type class for types which can be safely cast to <a>Scale</a>, for
--   instance with <a>toScale</a>.
class (GObject o, IsDescendantOf Scale o) => IsScale o

-- | Signal which allows you to change how the scale value is displayed.
--   Connect a signal handler which returns an allocated string
--   representing <i><tt>value</tt></i>. That string will then be used to
--   display the scale's value.
--   
--   If no user-provided handlers are installed, the value will be
--   displayed on its own, rounded according to the value of the
--   <a>Scale:digits</a> property.
--   
--   Here's an example signal handler which displays a value 1.0 as with
--   "--&gt;1.0&lt;--".
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   static gchar*
--   format_value_callback (GtkScale *scale,
--                          gdouble   value)
--   {
--     return g_strdup_printf ("--&gt;\%0.*g&lt;--",
--                             gtk_scale_get_digits (scale), value);
--    }
--   </pre>
type ScaleFormatValueCallback = Double -> IO Text

-- | Type class for types which can be safely cast to <a>VScale</a>, for
--   instance with <a>toVScale</a>.
class (GObject o, IsDescendantOf VScale o) => IsVScale o

-- | Memory-managed wrapper type.
newtype () => VScale
VScale :: ManagedPtr VScale -> VScale

-- | Type class for types which can be safely cast to <a>ProgressBar</a>,
--   for instance with <a>toProgressBar</a>.
class (GObject o, IsDescendantOf ProgressBar o) => IsProgressBar o

-- | Memory-managed wrapper type.
newtype () => ProgressBar
ProgressBar :: ManagedPtr ProgressBar -> ProgressBar

-- | Type class for types which can be safely cast to
--   <a>PrintOperation</a>, for instance with <a>toPrintOperation</a>.
class (GObject o, IsDescendantOf PrintOperation o) => IsPrintOperation o

-- | Memory-managed wrapper type.
newtype () => PrintOperation
PrintOperation :: ManagedPtr PrintOperation -> PrintOperation

-- | Emitted after change of selected printer. The actual page setup and
--   print settings are passed to the custom widget, which can actualize
--   itself according to this change.
--   
--   <i>Since: 2.18</i>
type PrintOperationUpdateCustomWidgetCallback = Widget -> PageSetup -> PrintSettings -> IO ()

-- | Emitted at between the various phases of the print operation. See
--   <a>PrintStatus</a> for the phases that are being discriminated. Use
--   <a>printOperationGetStatus</a> to find out the current status.
--   
--   <i>Since: 2.10</i>
type PrintOperationStatusChangedCallback = IO ()

-- | Emitted once for every page that is printed, to give the application a
--   chance to modify the page setup. Any changes done to
--   <i><tt>setup</tt></i> will be in force only for printing this page.
--   
--   <i>Since: 2.10</i>
type PrintOperationRequestPageSetupCallback = PrintContext -> Int32 -> PageSetup -> IO ()

-- | Gets emitted when a preview is requested from the native dialog.
--   
--   The default handler for this signal uses an external viewer
--   application to preview.
--   
--   To implement a custom print preview, an application must return
--   <a>True</a> from its handler for this signal. In order to use the
--   provided <i><tt>context</tt></i> for the preview implementation, it
--   must be given a suitable cairo context with
--   <a>printContextSetCairoContext</a>.
--   
--   The custom preview implementation can use
--   <a>printOperationPreviewIsSelected</a> and
--   <a>printOperationPreviewRenderPage</a> to find pages which are
--   selected for print and render them. The preview must be finished by
--   calling <a>printOperationPreviewEndPreview</a> (typically in response
--   to the user clicking a close button).
--   
--   <i>Since: 2.10</i>
type PrintOperationPreviewCallback = PrintOperationPreview -> PrintContext -> Maybe Window -> IO Bool

-- | Emitted after the <a>PrintOperation::beginPrint</a> signal, but before
--   the actual rendering starts. It keeps getting emitted until a
--   connected signal handler returns <a>True</a>.
--   
--   The <a>paginate</a> signal is intended to be used for paginating a
--   document in small chunks, to avoid blocking the user interface for a
--   long time. The signal handler should update the number of pages using
--   <a>printOperationSetNPages</a>, and return <a>True</a> if the document
--   has been completely paginated.
--   
--   If you don't need to do pagination in chunks, you can simply do it all
--   in the <a>beginPrint</a> handler, and set the number of pages from
--   there.
--   
--   <i>Since: 2.10</i>
type PrintOperationPaginateCallback = PrintContext -> IO Bool

-- | Emitted after all pages have been rendered. A handler for this signal
--   can clean up any resources that have been allocated in the
--   <a>PrintOperation::beginPrint</a> handler.
--   
--   <i>Since: 2.10</i>
type PrintOperationEndPrintCallback = PrintContext -> IO ()

-- | Emitted for every page that is printed. The signal handler must render
--   the <i><tt>pageNr</tt></i>'s page onto the cairo context obtained from
--   <i><tt>context</tt></i> using <a>printContextGetCairoContext</a>.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   static void
--   draw_page (GtkPrintOperation *operation,
--              GtkPrintContext   *context,
--              gint               page_nr,
--              gpointer           user_data)
--   {
--     cairo_t *cr;
--     PangoLayout *layout;
--     gdouble width, text_height;
--     gint layout_height;
--     PangoFontDescription *desc;
--     
--     cr = gtk_print_context_get_cairo_context (context);
--     width = gtk_print_context_get_width (context);
--     
--     cairo_rectangle (cr, 0, 0, width, HEADER_HEIGHT);
--     
--     cairo_set_source_rgb (cr, 0.8, 0.8, 0.8);
--     cairo_fill (cr);
--     
--     layout = gtk_print_context_create_pango_layout (context);
--     
--     desc = pango_font_description_from_string ("sans 14");
--     pango_layout_set_font_description (layout, desc);
--     pango_font_description_free (desc);
--     
--     pango_layout_set_text (layout, "some text", -1);
--     pango_layout_set_width (layout, width * PANGO_SCALE);
--     pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
--        		      
--     pango_layout_get_size (layout, NULL, &amp;layout_height);
--     text_height = (gdouble)layout_height / PANGO_SCALE;
--     
--     cairo_move_to (cr, width / 2,  (HEADER_HEIGHT - text_height) / 2);
--     pango_cairo_show_layout (cr, layout);
--     
--     g_object_unref (layout);
--   }
--   </pre>
--   
--   Use <a>printOperationSetUseFullPage</a> and
--   <a>printOperationSetUnit</a> before starting the print operation to
--   set up the transformation of the cairo context according to your
--   needs.
--   
--   <i>Since: 2.10</i>
type PrintOperationDrawPageCallback = PrintContext -> Int32 -> IO ()

-- | Emitted when the print operation run has finished doing everything
--   required for printing.
--   
--   <i><tt>result</tt></i> gives you information about what happened
--   during the run. If <i><tt>result</tt></i> is
--   <a>PrintOperationResultError</a> then you can call
--   <a>printOperationGetError</a> for more information.
--   
--   If you enabled print status tracking then
--   <a>printOperationIsFinished</a> may still return <a>False</a> after
--   <a>PrintOperation::done</a> was emitted.
--   
--   <i>Since: 2.10</i>
type PrintOperationDoneCallback = PrintOperationResult -> IO ()

-- | Emitted right before <a>PrintOperation::beginPrint</a> if you added a
--   custom widget in the <a>PrintOperation::createCustomWidget</a>
--   handler. When you get this signal you should read the information from
--   the custom widgets, as the widgets are not guaraneed to be around at a
--   later time.
--   
--   <i>Since: 2.10</i>
type PrintOperationCustomWidgetApplyCallback = Widget -> IO ()

-- | Emitted when displaying the print dialog. If you return a widget in a
--   handler for this signal it will be added to a custom tab in the print
--   dialog. You typically return a container widget with multiple widgets
--   in it.
--   
--   The print dialog owns the returned widget, and its lifetime is not
--   controlled by the application. However, the widget is guaranteed to
--   stay around until the <a>PrintOperation::customWidgetApply</a> signal
--   is emitted on the operation. Then you can read out any information you
--   need from the widgets.
--   
--   <i>Since: 2.10</i>
type PrintOperationCreateCustomWidgetCallback = IO Object

-- | Emitted after the user has finished changing print settings in the
--   dialog, before the actual rendering starts.
--   
--   A typical use for <a>beginPrint</a> is to use the parameters from the
--   <a>PrintContext</a> and paginate the document accordingly, and then
--   set the number of pages with <a>printOperationSetNPages</a>.
--   
--   <i>Since: 2.10</i>
type PrintOperationBeginPrintCallback = PrintContext -> IO ()

-- | Type class for types which can be safely cast to <a>Popover</a>, for
--   instance with <a>toPopover</a>.
class (GObject o, IsDescendantOf Popover o) => IsPopover o

-- | This signal is emitted when the popover is dismissed either through
--   API or user interaction.
--   
--   <i>Since: 3.12</i>
type PopoverClosedCallback = IO ()

-- | Type class for types which can be safely cast to <a>PopoverMenu</a>,
--   for instance with <a>toPopoverMenu</a>.
class (GObject o, IsDescendantOf PopoverMenu o) => IsPopoverMenu o

-- | Memory-managed wrapper type.
newtype () => PopoverMenu
PopoverMenu :: ManagedPtr PopoverMenu -> PopoverMenu

-- | Type class for types which can be safely cast to <a>Plug</a>, for
--   instance with <a>toPlug</a>.
class (GObject o, IsDescendantOf Plug o) => IsPlug o

-- | Gets emitted when the plug becomes embedded in a socket.
type PlugEmbeddedCallback = IO ()

-- | Type class for types which can be safely cast to <a>PlacesSidebar</a>,
--   for instance with <a>toPlacesSidebar</a>.
class (GObject o, IsDescendantOf PlacesSidebar o) => IsPlacesSidebar o

-- | The places sidebar emits this signal when it starts a new operation
--   because the user for example ejected some drive or unmounted a mount.
--   In this way the application using the <a>PlacesSidebar</a> can track
--   the progress of the operation and, for example, show a notification.
--   
--   <i>Since: 3.20</i>
type PlacesSidebarUnmountCallback = MountOperation -> IO ()

-- | The places sidebar emits this signal when it needs the calling
--   application to present a way to show the starred files. In GNOME,
--   starred files are implemented by setting the
--   nao:predefined-tag-favorite tag in the tracker database.
--   
--   <i>Since: 3.22.26</i>
type PlacesSidebarShowStarredLocationCallback = [PlacesOpenFlags] -> IO ()

-- | The places sidebar emits this signal when it needs the calling
--   application to present a way to show other locations e.g. drives and
--   network access points. For example, the application may bring up a
--   page showing persistent volumes and discovered network addresses.
--   
--   <i>Since: 3.20</i>
type PlacesSidebarShowOtherLocationsWithFlagsCallback = [PlacesOpenFlags] -> IO ()

-- | The places sidebar emits this signal when it needs the calling
--   application to present a way to show other locations e.g. drives and
--   network access points. For example, the application may bring up a
--   page showing persistent volumes and discovered network addresses.
--   
--   <i>Since: 3.18</i>
type PlacesSidebarShowOtherLocationsCallback = IO ()

-- | The places sidebar emits this signal when it needs the calling
--   application to present an error message. Most of these messages refer
--   to mounting or unmounting media, for example, when a drive cannot be
--   started for some reason.
--   
--   <i>Since: 3.10</i>
type PlacesSidebarShowErrorMessageCallback = Text -> Text -> IO ()

-- | The places sidebar emits this signal when it needs the calling
--   application to present an way to directly enter a location. For
--   example, the application may bring up a dialog box asking for a URL
--   like "http://http.example.com".
--   
--   <i>Since: 3.14</i>
type PlacesSidebarShowEnterLocationCallback = IO ()

-- | The places sidebar emits this signal when it needs the calling
--   application to present an way to connect directly to a network server.
--   For example, the application may bring up a dialog box asking for a
--   URL like "sftp://ftp.example.com". It is up to the application to
--   create the corresponding mount by using, for example,
--   <a>fileMountEnclosingVolume</a>.
type PlacesSidebarShowConnectToServerCallback = IO ()

-- | The places sidebar emits this signal when the user invokes a
--   contextual popup on one of its items. In the signal handler, the
--   application may add extra items to the menu as appropriate. For
--   example, a file manager may want to add a "Properties" command to the
--   menu.
--   
--   It is not necessary to store the <i><tt>selectedItem</tt></i> for each
--   menu item; during their callbacks, the application can use
--   <a>placesSidebarGetLocation</a> to get the file to which the item
--   refers.
--   
--   The <i><tt>selectedItem</tt></i> argument may be <a>Nothing</a> in
--   case the selection refers to a volume. In this case,
--   <i><tt>selectedVolume</tt></i> will be non-<a>Nothing</a>. In this
--   case, the calling application will have to <a>objectRef</a> the
--   <i><tt>selectedVolume</tt></i> and keep it around to use it in the
--   callback.
--   
--   The <i><tt>container</tt></i> and all its contents are destroyed after
--   the user dismisses the popup. The popup is re-created (and thus, this
--   signal is emitted) every time the user activates the contextual menu.
--   
--   Before 3.18, the <i><tt>container</tt></i> always was a <a>Menu</a>,
--   and you were expected to add your items as
--   <tt><i>GtkMenuItems</i></tt>. Since 3.18, the popup may be implemented
--   as a <a>Popover</a>, in which case <i><tt>container</tt></i> will be
--   something else, e.g. a <a>Box</a>, to which you may add
--   <tt><i>GtkModelButtons</i></tt> or other widgets, such as
--   <tt><i>GtkEntries</i></tt>, <tt><i>GtkSpinButtons</i></tt>, etc. If
--   your application can deal with this situation, you can set
--   <a>PlacesSidebar</a>::<tt><i>populate-all</i></tt> to <a>True</a> to
--   request that this signal is emitted for populating popovers as well.
--   
--   <i>Since: 3.10</i>
type PlacesSidebarPopulatePopupCallback = Widget -> Maybe File -> Maybe Volume -> IO ()

-- | The places sidebar emits this signal when the user selects a location
--   in it. The calling application should display the contents of that
--   location; for example, a file manager should show a list of files in
--   the specified location.
--   
--   <i>Since: 3.10</i>
type PlacesSidebarOpenLocationCallback = File -> [PlacesOpenFlags] -> IO ()

-- | The places sidebar emits this signal when it starts a new operation
--   because the user clicked on some location that needs mounting. In this
--   way the application using the <a>PlacesSidebar</a> can track the
--   progress of the operation and, for example, show a notification.
--   
--   <i>Since: 3.20</i>
type PlacesSidebarMountCallback = MountOperation -> IO ()

-- | The places sidebar emits this signal when the user completes a
--   drag-and-drop operation and one of the sidebar's items is the
--   destination. This item is in the <i><tt>destFile</tt></i>, and the
--   <i><tt>sourceFileList</tt></i> has the list of files that are dropped
--   into it and which should be copied/moved/etc. based on the specified
--   <i><tt>action</tt></i>.
--   
--   <i>Since: 3.10</i>
type PlacesSidebarDragPerformDropCallback = File -> [File] -> Int32 -> IO ()

-- | When the user starts a drag-and-drop operation and the sidebar needs
--   to ask the application for which drag action to perform, then the
--   sidebar will emit this signal.
--   
--   The application can evaluate the <i><tt>context</tt></i> for customary
--   actions, or it can check the type of the files indicated by
--   <i><tt>sourceFileList</tt></i> against the possible actions for the
--   destination <i><tt>destFile</tt></i>.
--   
--   The drag action to use must be the return value of the signal handler.
--   
--   <i>Since: 3.10</i>
type PlacesSidebarDragActionRequestedCallback = DragContext -> File -> [File] -> IO Int32

-- | The places sidebar emits this signal when it needs to ask the
--   application to pop up a menu to ask the user for which drag action to
--   perform.
--   
--   <i>Since: 3.10</i>
type PlacesSidebarDragActionAskCallback = Int32 -> IO Int32

-- | Type class for types which can be safely cast to <a>Paned</a>, for
--   instance with <a>toPaned</a>.
class (GObject o, IsDescendantOf Paned o) => IsPaned o

-- | The <a>toggleHandleFocus</a> is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to accept the current
--   position of the handle and then move focus to the next widget in the
--   focus chain.
--   
--   The default binding is Tab.
--   
--   <i>Since: 2.0</i>
type PanedToggleHandleFocusCallback = IO Bool

-- | The <a>moveHandle</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to move the handle when
--   the user is using key bindings to move it.
--   
--   <i>Since: 2.0</i>
type PanedMoveHandleCallback = ScrollType -> IO Bool

-- | The <a>cycleHandleFocus</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to cycle whether the
--   paned should grab focus to allow the user to change position of the
--   handle by using key bindings.
--   
--   The default binding for this signal is f8.
--   
--   <i>Since: 2.0</i>
type PanedCycleHandleFocusCallback = Bool -> IO Bool

-- | The <a>cycleChildFocus</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to cycle the focus
--   between the children of the paned.
--   
--   The default binding is f6.
--   
--   <i>Since: 2.0</i>
type PanedCycleChildFocusCallback = Bool -> IO Bool

-- | The <a>cancelPosition</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to cancel moving the
--   position of the handle using key bindings. The position of the handle
--   will be reset to the value prior to moving it.
--   
--   The default binding for this signal is Escape.
--   
--   <i>Since: 2.0</i>
type PanedCancelPositionCallback = IO Bool

-- | The <a>acceptPosition</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to accept the current
--   position of the handle when moving it using key bindings.
--   
--   The default binding for this signal is Return or Space.
--   
--   <i>Since: 2.0</i>
type PanedAcceptPositionCallback = IO Bool

-- | Type class for types which can be safely cast to <a>VPaned</a>, for
--   instance with <a>toVPaned</a>.
class (GObject o, IsDescendantOf VPaned o) => IsVPaned o

-- | Memory-managed wrapper type.
newtype () => VPaned
VPaned :: ManagedPtr VPaned -> VPaned

-- | Type class for types which can be safely cast to <a>Overlay</a>, for
--   instance with <a>toOverlay</a>.
class (GObject o, IsDescendantOf Overlay o) => IsOverlay o

-- | Memory-managed wrapper type.
newtype () => Overlay
Overlay :: ManagedPtr Overlay -> Overlay

-- | The <a>getChildPosition</a> signal is emitted to determine the
--   position and size of any overlay child widgets. A handler for this
--   signal should fill <i><tt>allocation</tt></i> with the desired
--   position and size for <i><tt>widget</tt></i>, relative to the 'main'
--   child of <i><tt>overlay</tt></i>.
--   
--   The default handler for this signal uses the <i><tt>widget</tt></i>'s
--   halign and valign properties to determine the position and gives the
--   widget its natural size (except that an alignment of <a>AlignFill</a>
--   will cause the overlay to be full-width/height). If the main child is
--   a <a>ScrolledWindow</a>, the overlays are placed relative to its
--   contents.
type OverlayGetChildPositionCallback = Widget -> Rectangle -> IO Bool

-- | Type class for types which can be safely cast to
--   <a>OffscreenWindow</a>, for instance with <a>toOffscreenWindow</a>.
class (GObject o, IsDescendantOf OffscreenWindow o) => IsOffscreenWindow o

-- | Memory-managed wrapper type.
newtype () => OffscreenWindow
OffscreenWindow :: ManagedPtr OffscreenWindow -> OffscreenWindow

-- | Type class for types which can be safely cast to <a>NumerableIcon</a>,
--   for instance with <a>toNumerableIcon</a>.
class (GObject o, IsDescendantOf NumerableIcon o) => IsNumerableIcon o

-- | Memory-managed wrapper type.
newtype () => NumerableIcon
NumerableIcon :: ManagedPtr NumerableIcon -> NumerableIcon

-- | Type class for types which can be safely cast to <a>Notebook</a>, for
--   instance with <a>toNotebook</a>.
class (GObject o, IsDescendantOf Notebook o) => IsNotebook o

-- | Emitted when the user or a function changes the current page.
type NotebookSwitchPageCallback = Widget -> Word32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type NotebookSelectPageCallback = Bool -> IO Bool

-- | <i>No description available in the introspection data.</i>
type NotebookReorderTabCallback = DirectionType -> Bool -> IO Bool

-- | the <a>pageReordered</a> signal is emitted in the notebook right after
--   a page has been reordered.
--   
--   <i>Since: 2.10</i>
type NotebookPageReorderedCallback = Widget -> Word32 -> IO ()

-- | the <a>pageRemoved</a> signal is emitted in the notebook right after a
--   page is removed from the notebook.
--   
--   <i>Since: 2.10</i>
type NotebookPageRemovedCallback = Widget -> Word32 -> IO ()

-- | the <a>pageAdded</a> signal is emitted in the notebook right after a
--   page is added to the notebook.
--   
--   <i>Since: 2.10</i>
type NotebookPageAddedCallback = Widget -> Word32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type NotebookMoveFocusOutCallback = DirectionType -> IO ()

-- | <i>No description available in the introspection data.</i>
type NotebookFocusTabCallback = NotebookTab -> IO Bool

-- | The <a>createWindow</a> signal is emitted when a detachable tab is
--   dropped on the root window.
--   
--   A handler for this signal can create a window containing a notebook
--   where the tab will be attached. It is also responsible for
--   moving/resizing the window and adding the necessary properties to the
--   notebook (e.g. the <a>Notebook:groupName</a> ).
--   
--   <i>Since: 2.12</i>
type NotebookCreateWindowCallback = Widget -> Int32 -> Int32 -> IO Notebook

-- | <i>No description available in the introspection data.</i>
type NotebookChangeCurrentPageCallback = Int32 -> IO Bool

-- | Type class for types which can be safely cast to <a>NativeDialog</a>,
--   for instance with <a>toNativeDialog</a>.
class (GObject o, IsDescendantOf NativeDialog o) => IsNativeDialog o

-- | Memory-managed wrapper type.
newtype () => NativeDialog
NativeDialog :: ManagedPtr NativeDialog -> NativeDialog

-- | Emitted when the user responds to the dialog.
--   
--   When this is called the dialog has been hidden.
--   
--   If you call <a>nativeDialogHide</a> before the user responds to the
--   dialog this signal will not be emitted.
--   
--   <i>Since: 3.20</i>
type NativeDialogResponseCallback = Int32 -> IO ()

-- | Type class for types which can be safely cast to
--   <a>MountOperation</a>, for instance with <a>toMountOperation</a>.
class (GObject o, IsDescendantOf MountOperation o) => IsMountOperation o

-- | Type class for types which can be safely cast to <a>Misc</a>, for
--   instance with <a>toMisc</a>.
class (GObject o, IsDescendantOf Misc o) => IsMisc o

-- | Type class for types which can be safely cast to <a>LevelBar</a>, for
--   instance with <a>toLevelBar</a>.
class (GObject o, IsDescendantOf LevelBar o) => IsLevelBar o

-- | Emitted when an offset specified on the bar changes value as an effect
--   to <a>levelBarAddOffsetValue</a> being called.
--   
--   The signal supports detailed connections; you can connect to the
--   detailed signal "changed<a>x</a>" in order to only receive callbacks
--   when the value of offset "x" changes.
--   
--   <i>Since: 3.6</i>
type LevelBarOffsetChangedCallback = Text -> IO ()

-- | Type class for types which can be safely cast to <a>Layout</a>, for
--   instance with <a>toLayout</a>.
class (GObject o, IsDescendantOf Layout o) => IsLayout o

-- | Type class for types which can be safely cast to <a>Invisible</a>, for
--   instance with <a>toInvisible</a>.
class (GObject o, IsDescendantOf Invisible o) => IsInvisible o

-- | Type class for types which can be safely cast to <a>Image</a>, for
--   instance with <a>toImage</a>.
class (GObject o, IsDescendantOf Image o) => IsImage o

-- | Type class for types which can be safely cast to <a>IconTheme</a>, for
--   instance with <a>toIconTheme</a>.
class (GObject o, IsDescendantOf IconTheme o) => IsIconTheme o

-- | Type class for types which can be safely cast to <a>IconInfo</a>, for
--   instance with <a>toIconInfo</a>.
class (GObject o, IsDescendantOf IconInfo o) => IsIconInfo o

-- | Emitted when the current icon theme is switched or GTK+ detects that a
--   change has occurred in the contents of the current icon theme.
type IconThemeChangedCallback = IO ()

-- | Type class for types which can be safely cast to <a>HeaderBar</a>, for
--   instance with <a>toHeaderBar</a>.
class (GObject o, IsDescendantOf HeaderBar o) => IsHeaderBar o

-- | Type class for types which can be safely cast to <a>HandleBox</a>, for
--   instance with <a>toHandleBox</a>.
class (GObject o, IsDescendantOf HandleBox o) => IsHandleBox o

-- | This signal is emitted when the contents of the handlebox are detached
--   from the main window.
type HandleBoxChildDetachedCallback = Widget -> IO ()

-- | This signal is emitted when the contents of the handlebox are
--   reattached to the main window.
type HandleBoxChildAttachedCallback = Widget -> IO ()

-- | Type class for types which can be safely cast to <a>HSeparator</a>,
--   for instance with <a>toHSeparator</a>.
class (GObject o, IsDescendantOf HSeparator o) => IsHSeparator o

-- | Memory-managed wrapper type.
newtype () => HSeparator
HSeparator :: ManagedPtr HSeparator -> HSeparator

-- | Type class for types which can be safely cast to <a>HScrollbar</a>,
--   for instance with <a>toHScrollbar</a>.
class (GObject o, IsDescendantOf HScrollbar o) => IsHScrollbar o

-- | Memory-managed wrapper type.
newtype () => HScrollbar
HScrollbar :: ManagedPtr HScrollbar -> HScrollbar

-- | Type class for types which can be safely cast to <a>HScale</a>, for
--   instance with <a>toHScale</a>.
class (GObject o, IsDescendantOf HScale o) => IsHScale o

-- | Memory-managed wrapper type.
newtype () => HScale
HScale :: ManagedPtr HScale -> HScale

-- | Type class for types which can be safely cast to <a>HSV</a>, for
--   instance with <a>toHSV</a>.
class (GObject o, IsDescendantOf HSV o) => IsHSV o

-- | Memory-managed wrapper type.
newtype () => HSV
HSV :: ManagedPtr HSV -> HSV

-- | <i>No description available in the introspection data.</i>
type HSVMoveCallback = DirectionType -> IO ()

-- | <i>No description available in the introspection data.</i>
type HSVChangedCallback = IO ()

-- | Type class for types which can be safely cast to <a>HPaned</a>, for
--   instance with <a>toHPaned</a>.
class (GObject o, IsDescendantOf HPaned o) => IsHPaned o

-- | Memory-managed wrapper type.
newtype () => HPaned
HPaned :: ManagedPtr HPaned -> HPaned

-- | Type class for types which can be safely cast to <a>Grid</a>, for
--   instance with <a>toGrid</a>.
class (GObject o, IsDescendantOf Grid o) => IsGrid o

-- | Type class for types which can be safely cast to <a>GLArea</a>, for
--   instance with <a>toGLArea</a>.
class (GObject o, IsDescendantOf GLArea o) => IsGLArea o

-- | Memory-managed wrapper type.
newtype () => GLArea
GLArea :: ManagedPtr GLArea -> GLArea

-- | The <a>resize</a> signal is emitted once when the widget is realized,
--   and then each time the widget is changed while realized. This is
--   useful in order to keep GL state up to date with the widget size, like
--   for instance camera properties which may depend on the width/height
--   ratio.
--   
--   The GL context for the area is guaranteed to be current when this
--   signal is emitted.
--   
--   The default handler sets up the GL viewport.
--   
--   <i>Since: 3.16</i>
type GLAreaResizeCallback = Int32 -> Int32 -> IO ()

-- | The <a>render</a> signal is emitted every time the contents of the
--   <a>GLArea</a> should be redrawn.
--   
--   The <i><tt>context</tt></i> is bound to the <i><tt>area</tt></i> prior
--   to emitting this function, and the buffers are painted to the window
--   once the emission terminates.
--   
--   <i>Since: 3.16</i>
type GLAreaRenderCallback = GLContext -> IO Bool

-- | The <a>createContext</a> signal is emitted when the widget is being
--   realized, and allows you to override how the GL context is created.
--   This is useful when you want to reuse an existing GL context, or if
--   you want to try creating different kinds of GL options.
--   
--   If context creation fails then the signal handler can use
--   <a>gLAreaSetError</a> to register a more detailed error of how the
--   construction failed.
--   
--   <i>Since: 3.16</i>
type GLAreaCreateContextCallback = IO GLContext

-- | Type class for types which can be safely cast to <a>Frame</a>, for
--   instance with <a>toFrame</a>.
class (GObject o, IsDescendantOf Frame o) => IsFrame o

-- | Type class for types which can be safely cast to <a>Fixed</a>, for
--   instance with <a>toFixed</a>.
class (GObject o, IsDescendantOf Fixed o) => IsFixed o

-- | Type class for types which can be safely cast to <a>FileFilter</a>,
--   for instance with <a>toFileFilter</a>.
class (GObject o, IsDescendantOf FileFilter o) => IsFileFilter o

-- | Type class for types which can be safely cast to <a>Expander</a>, for
--   instance with <a>toExpander</a>.
class (GObject o, IsDescendantOf Expander o) => IsExpander o

-- | <i>No description available in the introspection data.</i>
type ExpanderActivateCallback = IO ()

-- | Type class for types which can be safely cast to
--   <a>EventController</a>, for instance with <a>toEventController</a>.
class (GObject o, IsDescendantOf EventController o) => IsEventController o

-- | Type class for types which can be safely cast to <a>PadController</a>,
--   for instance with <a>toPadController</a>.
class (GObject o, IsDescendantOf PadController o) => IsPadController o

-- | Memory-managed wrapper type.
newtype () => PadController
PadController :: ManagedPtr PadController -> PadController

-- | Type class for types which can be safely cast to <a>Gesture</a>, for
--   instance with <a>toGesture</a>.
class (GObject o, IsDescendantOf Gesture o) => IsGesture o

-- | This signal is emitted whenever an event is handled while the gesture
--   is recognized. <i><tt>sequence</tt></i> is guaranteed to pertain to
--   the set of active touches.
--   
--   <i>Since: 3.14</i>
type GestureUpdateCallback = Maybe EventSequence -> IO ()

-- | This signal is emitted whenever a sequence state changes. See
--   <a>gestureSetSequenceState</a> to know more about the expectable
--   sequence lifetimes.
--   
--   <i>Since: 3.14</i>
type GestureSequenceStateChangedCallback = Maybe EventSequence -> EventSequenceState -> IO ()

-- | This signal is emitted when <i><tt>gesture</tt></i> either stopped
--   recognizing the event sequences as something to be handled (the
--   <a>Gesture</a>::<tt><i>check</i></tt> handler returned <a>False</a>),
--   or the number of touch sequences became higher or lower than
--   <a>Gesture:nPoints</a>.
--   
--   Note: <i><tt>sequence</tt></i> might not pertain to the group of
--   sequences that were previously triggering recognition on
--   <i><tt>gesture</tt></i> (ie. a just pressed touch sequence that
--   exceeds <a>Gesture:nPoints</a>). This situation may be detected by
--   checking through <a>gestureHandlesSequence</a>.
--   
--   <i>Since: 3.14</i>
type GestureEndCallback = Maybe EventSequence -> IO ()

-- | This signal is emitted whenever a sequence is cancelled. This usually
--   happens on active touches when <a>eventControllerReset</a> is called
--   on <i><tt>gesture</tt></i> (manually, due to grabs...), or the
--   individual <i><tt>sequence</tt></i> was claimed by parent widgets'
--   controllers (see <a>gestureSetSequenceState</a>).
--   
--   <i><tt>gesture</tt></i> must forget everything about
--   <i><tt>sequence</tt></i> as a reaction to this signal.
--   
--   <i>Since: 3.14</i>
type GestureCancelCallback = Maybe EventSequence -> IO ()

-- | This signal is emitted when the gesture is recognized. This means the
--   number of touch sequences matches <a>Gesture:nPoints</a>, and the
--   <a>Gesture</a>::<tt><i>check</i></tt> handler(s) returned
--   <tt><i>TRUE</i></tt>.
--   
--   Note: These conditions may also happen when an extra touch (eg. a
--   third touch on a 2-touches gesture) is lifted, in that situation
--   <i><tt>sequence</tt></i> won't pertain to the current set of active
--   touches, so don't rely on this being true.
--   
--   <i>Since: 3.14</i>
type GestureBeginCallback = Maybe EventSequence -> IO ()

-- | Type class for types which can be safely cast to <a>GestureZoom</a>,
--   for instance with <a>toGestureZoom</a>.
class (GObject o, IsDescendantOf GestureZoom o) => IsGestureZoom o

-- | Memory-managed wrapper type.
newtype () => GestureZoom
GestureZoom :: ManagedPtr GestureZoom -> GestureZoom

-- | This signal is emitted whenever the distance between both tracked
--   sequences changes.
--   
--   <i>Since: 3.14</i>
type GestureZoomScaleChangedCallback = Double -> IO ()

-- | Type class for types which can be safely cast to <a>GestureSingle</a>,
--   for instance with <a>toGestureSingle</a>.
class (GObject o, IsDescendantOf GestureSingle o) => IsGestureSingle o

-- | Memory-managed wrapper type.
newtype () => GestureSingle
GestureSingle :: ManagedPtr GestureSingle -> GestureSingle

-- | Type class for types which can be safely cast to <a>GestureSwipe</a>,
--   for instance with <a>toGestureSwipe</a>.
class (GObject o, IsDescendantOf GestureSwipe o) => IsGestureSwipe o

-- | Memory-managed wrapper type.
newtype () => GestureSwipe
GestureSwipe :: ManagedPtr GestureSwipe -> GestureSwipe

-- | This signal is emitted when the recognized gesture is finished,
--   velocity and direction are a product of previously recorded events.
--   
--   <i>Since: 3.14</i>
type GestureSwipeSwipeCallback = Double -> Double -> IO ()

-- | Type class for types which can be safely cast to <a>GestureStylus</a>,
--   for instance with <a>toGestureStylus</a>.
class (GObject o, IsDescendantOf GestureStylus o) => IsGestureStylus o

-- | Memory-managed wrapper type.
newtype () => GestureStylus
GestureStylus :: ManagedPtr GestureStylus -> GestureStylus

-- | <i>No description available in the introspection data.</i>
type GestureStylusUpCallback = Double -> Double -> IO ()

-- | <i>No description available in the introspection data.</i>
type GestureStylusProximityCallback = Double -> Double -> IO ()

-- | <i>No description available in the introspection data.</i>
type GestureStylusMotionCallback = Double -> Double -> IO ()

-- | <i>No description available in the introspection data.</i>
type GestureStylusDownCallback = Double -> Double -> IO ()

-- | Type class for types which can be safely cast to <a>GestureRotate</a>,
--   for instance with <a>toGestureRotate</a>.
class (GObject o, IsDescendantOf GestureRotate o) => IsGestureRotate o

-- | Memory-managed wrapper type.
newtype () => GestureRotate
GestureRotate :: ManagedPtr GestureRotate -> GestureRotate

-- | This signal is emitted when the angle between both tracked points
--   changes.
--   
--   <i>Since: 3.14</i>
type GestureRotateAngleChangedCallback = Double -> Double -> IO ()

-- | Type class for types which can be safely cast to
--   <a>GestureMultiPress</a>, for instance with
--   <a>toGestureMultiPress</a>.
class (GObject o, IsDescendantOf GestureMultiPress o) => IsGestureMultiPress o

-- | Memory-managed wrapper type.
newtype () => GestureMultiPress
GestureMultiPress :: ManagedPtr GestureMultiPress -> GestureMultiPress

-- | This signal is emitted whenever any time/distance threshold has been
--   exceeded.
--   
--   <i>Since: 3.14</i>
type GestureMultiPressStoppedCallback = IO ()

-- | This signal is emitted when a button or touch is released.
--   <i><tt>nPress</tt></i> will report the number of press that is paired
--   to this event, note that <a>GestureMultiPress::stopped</a> may have
--   been emitted between the press and its release, <i><tt>nPress</tt></i>
--   will only start over at the next press.
--   
--   <i>Since: 3.14</i>
type GestureMultiPressReleasedCallback = Int32 -> Double -> Double -> IO ()

-- | This signal is emitted whenever a button or touch press happens.
--   
--   <i>Since: 3.14</i>
type GestureMultiPressPressedCallback = Int32 -> Double -> Double -> IO ()

-- | Type class for types which can be safely cast to
--   <a>GestureLongPress</a>, for instance with <a>toGestureLongPress</a>.
class (GObject o, IsDescendantOf GestureLongPress o) => IsGestureLongPress o

-- | Memory-managed wrapper type.
newtype () => GestureLongPress
GestureLongPress :: ManagedPtr GestureLongPress -> GestureLongPress

-- | This signal is emitted whenever a press goes unmoved/unreleased longer
--   than what the GTK+ defaults tell.
--   
--   <i>Since: 3.14</i>
type GestureLongPressPressedCallback = Double -> Double -> IO ()

-- | This signal is emitted whenever a press moved too far, or was released
--   before <a>GestureLongPress::pressed</a> happened.
--   
--   <i>Since: 3.14</i>
type GestureLongPressCancelledCallback = IO ()

-- | Type class for types which can be safely cast to <a>GestureDrag</a>,
--   for instance with <a>toGestureDrag</a>.
class (GObject o, IsDescendantOf GestureDrag o) => IsGestureDrag o

-- | Memory-managed wrapper type.
newtype () => GestureDrag
GestureDrag :: ManagedPtr GestureDrag -> GestureDrag

-- | This signal is emitted whenever the dragging point moves.
--   
--   <i>Since: 3.14</i>
type GestureDragDragUpdateCallback = Double -> Double -> IO ()

-- | This signal is emitted whenever the dragging is finished.
--   
--   <i>Since: 3.14</i>
type GestureDragDragEndCallback = Double -> Double -> IO ()

-- | This signal is emitted whenever dragging starts.
--   
--   <i>Since: 3.14</i>
type GestureDragDragBeginCallback = Double -> Double -> IO ()

-- | Type class for types which can be safely cast to <a>GesturePan</a>,
--   for instance with <a>toGesturePan</a>.
class (GObject o, IsDescendantOf GesturePan o) => IsGesturePan o

-- | This signal is emitted once a panning gesture along the expected axis
--   is detected.
--   
--   <i>Since: 3.14</i>
type GesturePanPanCallback = PanDirection -> Double -> IO ()

-- | Type class for types which can be safely cast to
--   <a>EventControllerScroll</a>, for instance with
--   <a>toEventControllerScroll</a>.
class (GObject o, IsDescendantOf EventControllerScroll o) => IsEventControllerScroll o

-- | Signals that a new scrolling operation has finished. It will only be
--   emitted on devices capable of it.
type EventControllerScrollScrollEndCallback = IO ()

-- | Signals that a new scrolling operation has begun. It will only be
--   emitted on devices capable of it.
type EventControllerScrollScrollBeginCallback = IO ()

-- | Signals that the widget should scroll by the amount specified by
--   <i><tt>dx</tt></i> and <i><tt>dy</tt></i>.
type EventControllerScrollScrollCallback = Double -> Double -> IO ()

-- | Emitted after scroll is finished if the
--   <tt><i>GTK_EVENT_CONTROLLER_SCROLL_KINETIC</i></tt> flag is set.
--   <i><tt>velX</tt></i> and <i><tt>velY</tt></i> express the initial
--   velocity that was imprinted by the scroll events. <i><tt>velX</tt></i>
--   and <i><tt>velY</tt></i> are expressed in pixels/ms.
type EventControllerScrollDecelerateCallback = Double -> Double -> IO ()

-- | Type class for types which can be safely cast to
--   <a>EventControllerMotion</a>, for instance with
--   <a>toEventControllerMotion</a>.
class (GObject o, IsDescendantOf EventControllerMotion o) => IsEventControllerMotion o

-- | Memory-managed wrapper type.
newtype () => EventControllerMotion
EventControllerMotion :: ManagedPtr EventControllerMotion -> EventControllerMotion

-- | Emitted when the pointer moves inside the widget.
type EventControllerMotionMotionCallback = Double -> Double -> IO ()

-- | Signals that pointer has left the widget.
type EventControllerMotionLeaveCallback = IO ()

-- | Signals that the pointer has entered the widget.
type EventControllerMotionEnterCallback = Double -> Double -> IO ()

-- | Type class for types which can be safely cast to
--   <a>EventControllerKey</a>, for instance with
--   <a>toEventControllerKey</a>.
class (GObject o, IsDescendantOf EventControllerKey o) => IsEventControllerKey o

-- | Memory-managed wrapper type.
newtype () => EventControllerKey
EventControllerKey :: ManagedPtr EventControllerKey -> EventControllerKey

-- | <i>No description available in the introspection data.</i>
type EventControllerKeyModifiersCallback = [ModifierType] -> IO Bool

-- | This signal is emitted whenever a key is released.
--   
--   <i>Since: 3.24</i>
type EventControllerKeyKeyReleasedCallback = Word32 -> Word32 -> [ModifierType] -> IO ()

-- | This signal is emitted whenever a key is pressed.
--   
--   <i>Since: 3.24</i>
type EventControllerKeyKeyPressedCallback = Word32 -> Word32 -> [ModifierType] -> IO Bool

-- | <i>No description available in the introspection data.</i>
type EventControllerKeyImUpdateCallback = IO ()

-- | <i>No description available in the introspection data.</i>
type EventControllerKeyFocusOutCallback = IO ()

-- | <i>No description available in the introspection data.</i>
type EventControllerKeyFocusInCallback = IO ()

-- | Type class for types which can be safely cast to <a>EventBox</a>, for
--   instance with <a>toEventBox</a>.
class (GObject o, IsDescendantOf EventBox o) => IsEventBox o

-- | Type class for types which can be safely cast to <a>DrawingArea</a>,
--   for instance with <a>toDrawingArea</a>.
class (GObject o, IsDescendantOf DrawingArea o) => IsDrawingArea o

-- | Type class for types which can be safely cast to <a>CssProvider</a>,
--   for instance with <a>toCssProvider</a>.
class (GObject o, IsDescendantOf CssProvider o) => IsCssProvider o

-- | Signals that a parsing error occurred. the <i><tt>path</tt></i>,
--   <i><tt>line</tt></i> and <i><tt>position</tt></i> describe the actual
--   location of the error as accurately as possible.
--   
--   Parsing errors are never fatal, so the parsing will resume after the
--   error. Errors may however cause parts of the given data or even all of
--   it to not be parsed at all. So it is a useful idea to check that the
--   parsing succeeds by connecting to this signal.
--   
--   Note that this signal may be emitted at any time as the css provider
--   may opt to defer parsing parts or all of the input to a later time
--   than when a loading function was called.
type CssProviderParsingErrorCallback = CssSection -> GError -> IO ()

-- | Type class for types which can be safely cast to <a>Box</a>, for
--   instance with <a>toBox</a>.
class (GObject o, IsDescendantOf Box o) => IsBox o

-- | Type class for types which can be safely cast to <a>VBox</a>, for
--   instance with <a>toVBox</a>.
class (GObject o, IsDescendantOf VBox o) => IsVBox o

-- | Type class for types which can be safely cast to <a>Statusbar</a>, for
--   instance with <a>toStatusbar</a>.
class (GObject o, IsDescendantOf Statusbar o) => IsStatusbar o

-- | Is emitted whenever a new message gets pushed onto a statusbar's
--   stack.
type StatusbarTextPushedCallback = Word32 -> Text -> IO ()

-- | Is emitted whenever a new message is popped off a statusbar's stack.
type StatusbarTextPoppedCallback = Word32 -> Text -> IO ()

-- | Type class for types which can be safely cast to <a>StackSwitcher</a>,
--   for instance with <a>toStackSwitcher</a>.
class (GObject o, IsDescendantOf StackSwitcher o) => IsStackSwitcher o

-- | Type class for types which can be safely cast to
--   <a>ShortcutsShortcut</a>, for instance with
--   <a>toShortcutsShortcut</a>.
class (GObject o, IsDescendantOf ShortcutsShortcut o) => IsShortcutsShortcut o

-- | Memory-managed wrapper type.
newtype () => ShortcutsShortcut
ShortcutsShortcut :: ManagedPtr ShortcutsShortcut -> ShortcutsShortcut

-- | Type class for types which can be safely cast to
--   <a>ShortcutsSection</a>, for instance with <a>toShortcutsSection</a>.
class (GObject o, IsDescendantOf ShortcutsSection o) => IsShortcutsSection o

-- | Memory-managed wrapper type.
newtype () => ShortcutsSection
ShortcutsSection :: ManagedPtr ShortcutsSection -> ShortcutsSection

-- | <i>No description available in the introspection data.</i>
type ShortcutsSectionChangeCurrentPageCallback = Int32 -> IO Bool

-- | Type class for types which can be safely cast to
--   <a>ShortcutsGroup</a>, for instance with <a>toShortcutsGroup</a>.
class (GObject o, IsDescendantOf ShortcutsGroup o) => IsShortcutsGroup o

-- | Memory-managed wrapper type.
newtype () => ShortcutsGroup
ShortcutsGroup :: ManagedPtr ShortcutsGroup -> ShortcutsGroup

-- | Type class for types which can be safely cast to <a>ShortcutLabel</a>,
--   for instance with <a>toShortcutLabel</a>.
class (GObject o, IsDescendantOf ShortcutLabel o) => IsShortcutLabel o

-- | Memory-managed wrapper type.
newtype () => ShortcutLabel
ShortcutLabel :: ManagedPtr ShortcutLabel -> ShortcutLabel

-- | Type class for types which can be safely cast to <a>HBox</a>, for
--   instance with <a>toHBox</a>.
class (GObject o, IsDescendantOf HBox o) => IsHBox o

-- | Type class for types which can be safely cast to <a>FontSelection</a>,
--   for instance with <a>toFontSelection</a>.
class (GObject o, IsDescendantOf FontSelection o) => IsFontSelection o

-- | Type class for types which can be safely cast to
--   <a>FontChooserWidget</a>, for instance with
--   <a>toFontChooserWidget</a>.
class (GObject o, IsDescendantOf FontChooserWidget o) => IsFontChooserWidget o

-- | Memory-managed wrapper type.
newtype () => FontChooserWidget
FontChooserWidget :: ManagedPtr FontChooserWidget -> FontChooserWidget

-- | Type class for types which can be safely cast to <a>Dialog</a>, for
--   instance with <a>toDialog</a>.
class (GObject o, IsDescendantOf Dialog o) => IsDialog o

-- | Emitted when an action widget is clicked, the dialog receives a delete
--   event, or the application programmer calls <a>dialogResponse</a>. On a
--   delete event, the response ID is
--   <tt><i>GTK_RESPONSE_DELETE_EVENT</i></tt>. Otherwise, it depends on
--   which action widget was clicked.
type DialogResponseCallback = Int32 -> IO ()

-- | The <a>close</a> signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted when the user uses a keybinding to close the
--   dialog.
--   
--   The default binding for this signal is the Escape key.
type DialogCloseCallback = IO ()

-- | Type class for types which can be safely cast to <a>MessageDialog</a>,
--   for instance with <a>toMessageDialog</a>.
class (GObject o, IsDescendantOf MessageDialog o) => IsMessageDialog o

-- | Memory-managed wrapper type.
newtype () => MessageDialog
MessageDialog :: ManagedPtr MessageDialog -> MessageDialog

-- | Type class for types which can be safely cast to
--   <a>FontSelectionDialog</a>, for instance with
--   <a>toFontSelectionDialog</a>.
class (GObject o, IsDescendantOf FontSelectionDialog o) => IsFontSelectionDialog o

-- | Memory-managed wrapper type.
newtype () => FontSelectionDialog
FontSelectionDialog :: ManagedPtr FontSelectionDialog -> FontSelectionDialog

-- | Type class for types which can be safely cast to
--   <a>FontChooserDialog</a>, for instance with
--   <a>toFontChooserDialog</a>.
class (GObject o, IsDescendantOf FontChooserDialog o) => IsFontChooserDialog o

-- | Memory-managed wrapper type.
newtype () => FontChooserDialog
FontChooserDialog :: ManagedPtr FontChooserDialog -> FontChooserDialog

-- | Type class for types which can be safely cast to
--   <a>ColorSelectionDialog</a>, for instance with
--   <a>toColorSelectionDialog</a>.
class (GObject o, IsDescendantOf ColorSelectionDialog o) => IsColorSelectionDialog o

-- | Memory-managed wrapper type.
newtype () => ColorSelectionDialog
ColorSelectionDialog :: ManagedPtr ColorSelectionDialog -> ColorSelectionDialog

-- | Type class for types which can be safely cast to
--   <a>ColorSelection</a>, for instance with <a>toColorSelection</a>.
class (GObject o, IsDescendantOf ColorSelection o) => IsColorSelection o

-- | This signal is emitted when the color changes in the
--   <a>ColorSelection</a> according to its update policy.
type ColorSelectionColorChangedCallback = IO ()

-- | Type class for types which can be safely cast to
--   <a>ColorChooserWidget</a>, for instance with
--   <a>toColorChooserWidget</a>.
class (GObject o, IsDescendantOf ColorChooserWidget o) => IsColorChooserWidget o

-- | Type class for types which can be safely cast to
--   <a>ColorChooserDialog</a>, for instance with
--   <a>toColorChooserDialog</a>.
class (GObject o, IsDescendantOf ColorChooserDialog o) => IsColorChooserDialog o

-- | Memory-managed wrapper type.
newtype () => ColorChooserDialog
ColorChooserDialog :: ManagedPtr ColorChooserDialog -> ColorChooserDialog

-- | Type class for types which can be safely cast to <a>ButtonBox</a>, for
--   instance with <a>toButtonBox</a>.
class (GObject o, IsDescendantOf ButtonBox o) => IsButtonBox o

-- | Type class for types which can be safely cast to <a>VButtonBox</a>,
--   for instance with <a>toVButtonBox</a>.
class (GObject o, IsDescendantOf VButtonBox o) => IsVButtonBox o

-- | Memory-managed wrapper type.
newtype () => VButtonBox
VButtonBox :: ManagedPtr VButtonBox -> VButtonBox

-- | Type class for types which can be safely cast to <a>HButtonBox</a>,
--   for instance with <a>toHButtonBox</a>.
class (GObject o, IsDescendantOf HButtonBox o) => IsHButtonBox o

-- | Memory-managed wrapper type.
newtype () => HButtonBox
HButtonBox :: ManagedPtr HButtonBox -> HButtonBox

-- | Type class for types which can be safely cast to <a>Assistant</a>, for
--   instance with <a>toAssistant</a>.
class (GObject o, IsDescendantOf Assistant o) => IsAssistant o

-- | The <a>prepare</a> signal is emitted when a new page is set as the
--   assistant's current page, before making the new page visible.
--   
--   A handler for this signal can do any preparations which are necessary
--   before showing <i><tt>page</tt></i>.
--   
--   <i>Since: 2.10</i>
type AssistantPrepareCallback = Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type AssistantEscapeCallback = IO ()

-- | The <a>close</a> signal is emitted either when the close button of a
--   summary page is clicked, or when the apply button in the last page in
--   the flow (of type <a>AssistantPageTypeConfirm</a>) is clicked.
--   
--   <i>Since: 2.10</i>
type AssistantCloseCallback = IO ()

-- | The <a>cancel</a> signal is emitted when then the cancel button is
--   clicked.
--   
--   <i>Since: 2.10</i>
type AssistantCancelCallback = IO ()

-- | The <a>apply</a> signal is emitted when the apply button is clicked.
--   
--   The default behavior of the <a>Assistant</a> is to switch to the page
--   after the current page, unless the current page is the last one.
--   
--   A handler for the <a>apply</a> signal should carry out the actions for
--   which the wizard has collected data. If the action takes a long time
--   to complete, you might consider putting a page of type
--   <a>AssistantPageTypeProgress</a> after the confirmation page and
--   handle this operation within the <a>Assistant::prepare</a> signal of
--   the progress page.
--   
--   <i>Since: 2.10</i>
type AssistantApplyCallback = IO ()

-- | Type class for types which can be safely cast to <a>AspectFrame</a>,
--   for instance with <a>toAspectFrame</a>.
class (GObject o, IsDescendantOf AspectFrame o) => IsAspectFrame o

-- | Memory-managed wrapper type.
newtype () => AspectFrame
AspectFrame :: ManagedPtr AspectFrame -> AspectFrame

-- | Type class for types which can be safely cast to <a>Arrow</a>, for
--   instance with <a>toArrow</a>.
class (GObject o, IsDescendantOf Arrow o) => IsArrow o

-- | Type class for types which can be safely cast to
--   <a>ApplicationWindow</a>, for instance with
--   <a>toApplicationWindow</a>.
class (GObject o, IsDescendantOf ApplicationWindow o) => IsApplicationWindow o

-- | Type class for types which can be safely cast to <a>Alignment</a>, for
--   instance with <a>toAlignment</a>.
class (GObject o, IsDescendantOf Alignment o) => IsAlignment o

-- | Type class for types which can be safely cast to <a>ActionBar</a>, for
--   instance with <a>toActionBar</a>.
class (GObject o, IsDescendantOf ActionBar o) => IsActionBar o

-- | Memory-managed wrapper type.
newtype () => ActionBar
ActionBar :: ManagedPtr ActionBar -> ActionBar

-- | Type class for types which can be safely cast to <a>UIManager</a>, for
--   instance with <a>toUIManager</a>.
class (GObject o, IsDescendantOf UIManager o) => IsUIManager o

-- | The <a>preActivate</a> signal is emitted just before the
--   <i><tt>action</tt></i> is activated.
--   
--   This is intended for applications to get notification just before any
--   action is activated.
--   
--   <i>Since: 2.4</i>
type UIManagerPreActivateCallback = Action -> IO ()

-- | The <a>postActivate</a> signal is emitted just after the
--   <i><tt>action</tt></i> is activated.
--   
--   This is intended for applications to get notification just after any
--   action is activated.
--   
--   <i>Since: 2.4</i>
type UIManagerPostActivateCallback = Action -> IO ()

-- | The <a>disconnectProxy</a> signal is emitted after disconnecting a
--   proxy from an action in the group.
--   
--   <i>Since: 2.4</i>
type UIManagerDisconnectProxyCallback = Action -> Widget -> IO ()

-- | The <a>connectProxy</a> signal is emitted after connecting a proxy to
--   an action in the group.
--   
--   This is intended for simple customizations for which a custom action
--   class would be too clumsy, e.g. showing tooltips for menuitems in the
--   statusbar.
--   
--   <i>Since: 2.4</i>
type UIManagerConnectProxyCallback = Action -> Widget -> IO ()

-- | The <a>addWidget</a> signal is emitted for each generated menubar and
--   toolbar. It is not emitted for generated popup menus, which can be
--   obtained by <a>uIManagerGetWidget</a>.
--   
--   <i>Since: 2.4</i>
type UIManagerAddWidgetCallback = Widget -> IO ()

-- | The <a>actionsChanged</a> signal is emitted whenever the set of
--   actions changes.
--   
--   <i>Since: 2.4</i>
type UIManagerActionsChangedCallback = IO ()

-- | Type class for types which can be safely cast to <a>ToggleAction</a>,
--   for instance with <a>toToggleAction</a>.
class (GObject o, IsDescendantOf ToggleAction o) => IsToggleAction o

-- | Memory-managed wrapper type.
newtype () => ToggleAction
ToggleAction :: ManagedPtr ToggleAction -> ToggleAction

-- | Should be connected if you wish to perform an action whenever the
--   <a>ToggleAction</a> state is changed.
type ToggleActionToggledCallback = IO ()

-- | Type class for types which can be safely cast to <a>RadioAction</a>,
--   for instance with <a>toRadioAction</a>.
class (GObject o, IsDescendantOf RadioAction o) => IsRadioAction o

-- | Memory-managed wrapper type.
newtype () => RadioAction
RadioAction :: ManagedPtr RadioAction -> RadioAction

-- | The <a>changed</a> signal is emitted on every member of a radio group
--   when the active member is changed. The signal gets emitted after the
--   <a>activate</a> signals for the previous and current active members.
--   
--   <i>Since: 2.4</i>
type RadioActionChangedCallback = RadioAction -> IO ()

-- | Type class for types which can be safely cast to <a>Accessible</a>,
--   for instance with <a>toAccessible</a>.
class (GObject o, IsDescendantOf Accessible o) => IsAccessible o

-- | Memory-managed wrapper type.
newtype () => Accessible
Accessible :: ManagedPtr Accessible -> Accessible

-- | Type class for types which can be safely cast to
--   <a>WidgetAccessible</a>, for instance with <a>toWidgetAccessible</a>.
class (GObject o, IsDescendantOf WidgetAccessible o) => IsWidgetAccessible o

-- | Memory-managed wrapper type.
newtype () => WidgetAccessible
WidgetAccessible :: ManagedPtr WidgetAccessible -> WidgetAccessible

-- | Type class for types which can be safely cast to
--   <a>SwitchAccessible</a>, for instance with <a>toSwitchAccessible</a>.
class (GObject o, IsDescendantOf SwitchAccessible o) => IsSwitchAccessible o

-- | Memory-managed wrapper type.
newtype () => SwitchAccessible
SwitchAccessible :: ManagedPtr SwitchAccessible -> SwitchAccessible

-- | Type class for types which can be safely cast to
--   <a>SpinnerAccessible</a>, for instance with
--   <a>toSpinnerAccessible</a>.
class (GObject o, IsDescendantOf SpinnerAccessible o) => IsSpinnerAccessible o

-- | Memory-managed wrapper type.
newtype () => SpinnerAccessible
SpinnerAccessible :: ManagedPtr SpinnerAccessible -> SpinnerAccessible

-- | Type class for types which can be safely cast to
--   <a>RangeAccessible</a>, for instance with <a>toRangeAccessible</a>.
class (GObject o, IsDescendantOf RangeAccessible o) => IsRangeAccessible o

-- | Memory-managed wrapper type.
newtype () => RangeAccessible
RangeAccessible :: ManagedPtr RangeAccessible -> RangeAccessible

-- | Type class for types which can be safely cast to
--   <a>ScaleAccessible</a>, for instance with <a>toScaleAccessible</a>.
class (GObject o, IsDescendantOf ScaleAccessible o) => IsScaleAccessible o

-- | Memory-managed wrapper type.
newtype () => ScaleAccessible
ScaleAccessible :: ManagedPtr ScaleAccessible -> ScaleAccessible

-- | Type class for types which can be safely cast to
--   <a>ProgressBarAccessible</a>, for instance with
--   <a>toProgressBarAccessible</a>.
class (GObject o, IsDescendantOf ProgressBarAccessible o) => IsProgressBarAccessible o

-- | Memory-managed wrapper type.
newtype () => ProgressBarAccessible
ProgressBarAccessible :: ManagedPtr ProgressBarAccessible -> ProgressBarAccessible

-- | Type class for types which can be safely cast to
--   <a>LevelBarAccessible</a>, for instance with
--   <a>toLevelBarAccessible</a>.
class (GObject o, IsDescendantOf LevelBarAccessible o) => IsLevelBarAccessible o

-- | Memory-managed wrapper type.
newtype () => LevelBarAccessible
LevelBarAccessible :: ManagedPtr LevelBarAccessible -> LevelBarAccessible

-- | Type class for types which can be safely cast to
--   <a>LabelAccessible</a>, for instance with <a>toLabelAccessible</a>.
class (GObject o, IsDescendantOf LabelAccessible o) => IsLabelAccessible o

-- | Memory-managed wrapper type.
newtype () => LabelAccessible
LabelAccessible :: ManagedPtr LabelAccessible -> LabelAccessible

-- | Type class for types which can be safely cast to
--   <a>ImageAccessible</a>, for instance with <a>toImageAccessible</a>.
class (GObject o, IsDescendantOf ImageAccessible o) => IsImageAccessible o

-- | Memory-managed wrapper type.
newtype () => ImageAccessible
ImageAccessible :: ManagedPtr ImageAccessible -> ImageAccessible

-- | Type class for types which can be safely cast to
--   <a>EntryAccessible</a>, for instance with <a>toEntryAccessible</a>.
class (GObject o, IsDescendantOf EntryAccessible o) => IsEntryAccessible o

-- | Memory-managed wrapper type.
newtype () => EntryAccessible
EntryAccessible :: ManagedPtr EntryAccessible -> EntryAccessible

-- | Type class for types which can be safely cast to
--   <a>SpinButtonAccessible</a>, for instance with
--   <a>toSpinButtonAccessible</a>.
class (GObject o, IsDescendantOf SpinButtonAccessible o) => IsSpinButtonAccessible o

-- | Memory-managed wrapper type.
newtype () => SpinButtonAccessible
SpinButtonAccessible :: ManagedPtr SpinButtonAccessible -> SpinButtonAccessible

-- | Type class for types which can be safely cast to
--   <a>ContainerAccessible</a>, for instance with
--   <a>toContainerAccessible</a>.
class (GObject o, IsDescendantOf ContainerAccessible o) => IsContainerAccessible o

-- | Memory-managed wrapper type.
newtype () => ContainerAccessible
ContainerAccessible :: ManagedPtr ContainerAccessible -> ContainerAccessible

-- | Type class for types which can be safely cast to
--   <a>WindowAccessible</a>, for instance with <a>toWindowAccessible</a>.
class (GObject o, IsDescendantOf WindowAccessible o) => IsWindowAccessible o

-- | Memory-managed wrapper type.
newtype () => WindowAccessible
WindowAccessible :: ManagedPtr WindowAccessible -> WindowAccessible

-- | Type class for types which can be safely cast to
--   <a>TextViewAccessible</a>, for instance with
--   <a>toTextViewAccessible</a>.
class (GObject o, IsDescendantOf TextViewAccessible o) => IsTextViewAccessible o

-- | Memory-managed wrapper type.
newtype () => TextViewAccessible
TextViewAccessible :: ManagedPtr TextViewAccessible -> TextViewAccessible

-- | Type class for types which can be safely cast to
--   <a>StatusbarAccessible</a>, for instance with
--   <a>toStatusbarAccessible</a>.
class (GObject o, IsDescendantOf StatusbarAccessible o) => IsStatusbarAccessible o

-- | Memory-managed wrapper type.
newtype () => StatusbarAccessible
StatusbarAccessible :: ManagedPtr StatusbarAccessible -> StatusbarAccessible

-- | Type class for types which can be safely cast to
--   <a>StackAccessible</a>, for instance with <a>toStackAccessible</a>.
class (GObject o, IsDescendantOf StackAccessible o) => IsStackAccessible o

-- | Memory-managed wrapper type.
newtype () => StackAccessible
StackAccessible :: ManagedPtr StackAccessible -> StackAccessible

-- | Type class for types which can be safely cast to
--   <a>SocketAccessible</a>, for instance with <a>toSocketAccessible</a>.
class (GObject o, IsDescendantOf SocketAccessible o) => IsSocketAccessible o

-- | Memory-managed wrapper type.
newtype () => SocketAccessible
SocketAccessible :: ManagedPtr SocketAccessible -> SocketAccessible

-- | Type class for types which can be safely cast to
--   <a>ScrolledWindowAccessible</a>, for instance with
--   <a>toScrolledWindowAccessible</a>.
class (GObject o, IsDescendantOf ScrolledWindowAccessible o) => IsScrolledWindowAccessible o

-- | Memory-managed wrapper type.
newtype () => ScrolledWindowAccessible
ScrolledWindowAccessible :: ManagedPtr ScrolledWindowAccessible -> ScrolledWindowAccessible

-- | Type class for types which can be safely cast to
--   <a>PopoverAccessible</a>, for instance with
--   <a>toPopoverAccessible</a>.
class (GObject o, IsDescendantOf PopoverAccessible o) => IsPopoverAccessible o

-- | Memory-managed wrapper type.
newtype () => PopoverAccessible
PopoverAccessible :: ManagedPtr PopoverAccessible -> PopoverAccessible

-- | Type class for types which can be safely cast to
--   <a>PlugAccessible</a>, for instance with <a>toPlugAccessible</a>.
class (GObject o, IsDescendantOf PlugAccessible o) => IsPlugAccessible o

-- | Memory-managed wrapper type.
newtype () => PlugAccessible
PlugAccessible :: ManagedPtr PlugAccessible -> PlugAccessible

-- | Type class for types which can be safely cast to
--   <a>PanedAccessible</a>, for instance with <a>toPanedAccessible</a>.
class (GObject o, IsDescendantOf PanedAccessible o) => IsPanedAccessible o

-- | Memory-managed wrapper type.
newtype () => PanedAccessible
PanedAccessible :: ManagedPtr PanedAccessible -> PanedAccessible

-- | Type class for types which can be safely cast to
--   <a>NotebookAccessible</a>, for instance with
--   <a>toNotebookAccessible</a>.
class (GObject o, IsDescendantOf NotebookAccessible o) => IsNotebookAccessible o

-- | Memory-managed wrapper type.
newtype () => NotebookAccessible
NotebookAccessible :: ManagedPtr NotebookAccessible -> NotebookAccessible

-- | Type class for types which can be safely cast to
--   <a>NotebookPageAccessible</a>, for instance with
--   <a>toNotebookPageAccessible</a>.
class (GObject o, IsDescendantOf NotebookPageAccessible o) => IsNotebookPageAccessible o

-- | Memory-managed wrapper type.
newtype () => NotebookPageAccessible
NotebookPageAccessible :: ManagedPtr NotebookPageAccessible -> NotebookPageAccessible

-- | Type class for types which can be safely cast to
--   <a>MenuShellAccessible</a>, for instance with
--   <a>toMenuShellAccessible</a>.
class (GObject o, IsDescendantOf MenuShellAccessible o) => IsMenuShellAccessible o

-- | Memory-managed wrapper type.
newtype () => MenuShellAccessible
MenuShellAccessible :: ManagedPtr MenuShellAccessible -> MenuShellAccessible

-- | Type class for types which can be safely cast to
--   <a>MenuItemAccessible</a>, for instance with
--   <a>toMenuItemAccessible</a>.
class (GObject o, IsDescendantOf MenuItemAccessible o) => IsMenuItemAccessible o

-- | Memory-managed wrapper type.
newtype () => MenuItemAccessible
MenuItemAccessible :: ManagedPtr MenuItemAccessible -> MenuItemAccessible

-- | Type class for types which can be safely cast to
--   <a>MenuAccessible</a>, for instance with <a>toMenuAccessible</a>.
class (GObject o, IsDescendantOf MenuAccessible o) => IsMenuAccessible o

-- | Memory-managed wrapper type.
newtype () => MenuAccessible
MenuAccessible :: ManagedPtr MenuAccessible -> MenuAccessible

-- | Type class for types which can be safely cast to
--   <a>ListBoxRowAccessible</a>, for instance with
--   <a>toListBoxRowAccessible</a>.
class (GObject o, IsDescendantOf ListBoxRowAccessible o) => IsListBoxRowAccessible o

-- | Memory-managed wrapper type.
newtype () => ListBoxRowAccessible
ListBoxRowAccessible :: ManagedPtr ListBoxRowAccessible -> ListBoxRowAccessible

-- | Type class for types which can be safely cast to
--   <a>ListBoxAccessible</a>, for instance with
--   <a>toListBoxAccessible</a>.
class (GObject o, IsDescendantOf ListBoxAccessible o) => IsListBoxAccessible o

-- | Memory-managed wrapper type.
newtype () => ListBoxAccessible
ListBoxAccessible :: ManagedPtr ListBoxAccessible -> ListBoxAccessible

-- | Type class for types which can be safely cast to
--   <a>IconViewAccessible</a>, for instance with
--   <a>toIconViewAccessible</a>.
class (GObject o, IsDescendantOf IconViewAccessible o) => IsIconViewAccessible o

-- | Memory-managed wrapper type.
newtype () => IconViewAccessible
IconViewAccessible :: ManagedPtr IconViewAccessible -> IconViewAccessible

-- | Type class for types which can be safely cast to
--   <a>HeaderBarAccessible</a>, for instance with
--   <a>toHeaderBarAccessible</a>.
class (GObject o, IsDescendantOf HeaderBarAccessible o) => IsHeaderBarAccessible o

-- | Memory-managed wrapper type.
newtype () => HeaderBarAccessible
HeaderBarAccessible :: ManagedPtr HeaderBarAccessible -> HeaderBarAccessible

-- | Type class for types which can be safely cast to
--   <a>FrameAccessible</a>, for instance with <a>toFrameAccessible</a>.
class (GObject o, IsDescendantOf FrameAccessible o) => IsFrameAccessible o

-- | Memory-managed wrapper type.
newtype () => FrameAccessible
FrameAccessible :: ManagedPtr FrameAccessible -> FrameAccessible

-- | Type class for types which can be safely cast to
--   <a>FlowBoxChildAccessible</a>, for instance with
--   <a>toFlowBoxChildAccessible</a>.
class (GObject o, IsDescendantOf FlowBoxChildAccessible o) => IsFlowBoxChildAccessible o

-- | Memory-managed wrapper type.
newtype () => FlowBoxChildAccessible
FlowBoxChildAccessible :: ManagedPtr FlowBoxChildAccessible -> FlowBoxChildAccessible

-- | Type class for types which can be safely cast to
--   <a>FlowBoxAccessible</a>, for instance with
--   <a>toFlowBoxAccessible</a>.
class (GObject o, IsDescendantOf FlowBoxAccessible o) => IsFlowBoxAccessible o

-- | Memory-managed wrapper type.
newtype () => FlowBoxAccessible
FlowBoxAccessible :: ManagedPtr FlowBoxAccessible -> FlowBoxAccessible

-- | Type class for types which can be safely cast to
--   <a>FileChooserWidgetAccessible</a>, for instance with
--   <a>toFileChooserWidgetAccessible</a>.
class (GObject o, IsDescendantOf FileChooserWidgetAccessible o) => IsFileChooserWidgetAccessible o

-- | Memory-managed wrapper type.
newtype () => FileChooserWidgetAccessible
FileChooserWidgetAccessible :: ManagedPtr FileChooserWidgetAccessible -> FileChooserWidgetAccessible

-- | Type class for types which can be safely cast to
--   <a>ExpanderAccessible</a>, for instance with
--   <a>toExpanderAccessible</a>.
class (GObject o, IsDescendantOf ExpanderAccessible o) => IsExpanderAccessible o

-- | Memory-managed wrapper type.
newtype () => ExpanderAccessible
ExpanderAccessible :: ManagedPtr ExpanderAccessible -> ExpanderAccessible

-- | Type class for types which can be safely cast to
--   <a>ComboBoxAccessible</a>, for instance with
--   <a>toComboBoxAccessible</a>.
class (GObject o, IsDescendantOf ComboBoxAccessible o) => IsComboBoxAccessible o

-- | Memory-managed wrapper type.
newtype () => ComboBoxAccessible
ComboBoxAccessible :: ManagedPtr ComboBoxAccessible -> ComboBoxAccessible

-- | Type class for types which can be safely cast to
--   <a>CheckMenuItemAccessible</a>, for instance with
--   <a>toCheckMenuItemAccessible</a>.
class (GObject o, IsDescendantOf CheckMenuItemAccessible o) => IsCheckMenuItemAccessible o

-- | Memory-managed wrapper type.
newtype () => CheckMenuItemAccessible
CheckMenuItemAccessible :: ManagedPtr CheckMenuItemAccessible -> CheckMenuItemAccessible

-- | Type class for types which can be safely cast to
--   <a>RadioMenuItemAccessible</a>, for instance with
--   <a>toRadioMenuItemAccessible</a>.
class (GObject o, IsDescendantOf RadioMenuItemAccessible o) => IsRadioMenuItemAccessible o

-- | Memory-managed wrapper type.
newtype () => RadioMenuItemAccessible
RadioMenuItemAccessible :: ManagedPtr RadioMenuItemAccessible -> RadioMenuItemAccessible

-- | Type class for types which can be safely cast to
--   <a>CellAccessible</a>, for instance with <a>toCellAccessible</a>.
class (GObject o, IsDescendantOf CellAccessible o) => IsCellAccessible o

-- | Memory-managed wrapper type.
newtype () => CellAccessible
CellAccessible :: ManagedPtr CellAccessible -> CellAccessible

-- | Type class for types which can be safely cast to
--   <a>ContainerCellAccessible</a>, for instance with
--   <a>toContainerCellAccessible</a>.
class (GObject o, IsDescendantOf ContainerCellAccessible o) => IsContainerCellAccessible o

-- | Memory-managed wrapper type.
newtype () => ContainerCellAccessible
ContainerCellAccessible :: ManagedPtr ContainerCellAccessible -> ContainerCellAccessible

-- | Type class for types which can be safely cast to
--   <a>ButtonAccessible</a>, for instance with <a>toButtonAccessible</a>.
class (GObject o, IsDescendantOf ButtonAccessible o) => IsButtonAccessible o

-- | Memory-managed wrapper type.
newtype () => ButtonAccessible
ButtonAccessible :: ManagedPtr ButtonAccessible -> ButtonAccessible

-- | Type class for types which can be safely cast to
--   <a>ToggleButtonAccessible</a>, for instance with
--   <a>toToggleButtonAccessible</a>.
class (GObject o, IsDescendantOf ToggleButtonAccessible o) => IsToggleButtonAccessible o

-- | Memory-managed wrapper type.
newtype () => ToggleButtonAccessible
ToggleButtonAccessible :: ManagedPtr ToggleButtonAccessible -> ToggleButtonAccessible

-- | Type class for types which can be safely cast to
--   <a>ScaleButtonAccessible</a>, for instance with
--   <a>toScaleButtonAccessible</a>.
class (GObject o, IsDescendantOf ScaleButtonAccessible o) => IsScaleButtonAccessible o

-- | Memory-managed wrapper type.
newtype () => ScaleButtonAccessible
ScaleButtonAccessible :: ManagedPtr ScaleButtonAccessible -> ScaleButtonAccessible

-- | Type class for types which can be safely cast to
--   <a>RadioButtonAccessible</a>, for instance with
--   <a>toRadioButtonAccessible</a>.
class (GObject o, IsDescendantOf RadioButtonAccessible o) => IsRadioButtonAccessible o

-- | Memory-managed wrapper type.
newtype () => RadioButtonAccessible
RadioButtonAccessible :: ManagedPtr RadioButtonAccessible -> RadioButtonAccessible

-- | Type class for types which can be safely cast to
--   <a>MenuButtonAccessible</a>, for instance with
--   <a>toMenuButtonAccessible</a>.
class (GObject o, IsDescendantOf MenuButtonAccessible o) => IsMenuButtonAccessible o

-- | Memory-managed wrapper type.
newtype () => MenuButtonAccessible
MenuButtonAccessible :: ManagedPtr MenuButtonAccessible -> MenuButtonAccessible

-- | Type class for types which can be safely cast to
--   <a>LockButtonAccessible</a>, for instance with
--   <a>toLockButtonAccessible</a>.
class (GObject o, IsDescendantOf LockButtonAccessible o) => IsLockButtonAccessible o

-- | Memory-managed wrapper type.
newtype () => LockButtonAccessible
LockButtonAccessible :: ManagedPtr LockButtonAccessible -> LockButtonAccessible

-- | Type class for types which can be safely cast to
--   <a>LinkButtonAccessible</a>, for instance with
--   <a>toLinkButtonAccessible</a>.
class (GObject o, IsDescendantOf LinkButtonAccessible o) => IsLinkButtonAccessible o

-- | Memory-managed wrapper type.
newtype () => LinkButtonAccessible
LinkButtonAccessible :: ManagedPtr LinkButtonAccessible -> LinkButtonAccessible

-- | Type class for types which can be safely cast to
--   <a>ArrowAccessible</a>, for instance with <a>toArrowAccessible</a>.
class (GObject o, IsDescendantOf ArrowAccessible o) => IsArrowAccessible o

-- | Memory-managed wrapper type.
newtype () => ArrowAccessible
ArrowAccessible :: ManagedPtr ArrowAccessible -> ArrowAccessible

-- | Type class for types which can be safely cast to <a>AboutDialog</a>,
--   for instance with <a>toAboutDialog</a>.
class (GObject o, IsDescendantOf AboutDialog o) => IsAboutDialog o

-- | Memory-managed wrapper type.
newtype () => AboutDialog
AboutDialog :: ManagedPtr AboutDialog -> AboutDialog

-- | The signal which gets emitted to activate a URI. Applications may
--   connect to it to override the default behaviour, which is to call
--   <a>showUriOnWindow</a>.
--   
--   <i>Since: 2.24</i>
type AboutDialogActivateLinkCallback = Text -> IO Bool

-- | Type class for types which implement <a>TreeDragSource</a>.
class (ManagedPtrNewtype o, IsDescendantOf TreeDragSource o) => IsTreeDragSource o

-- | Memory-managed wrapper type.
newtype () => TreeDragSource
TreeDragSource :: ManagedPtr TreeDragSource -> TreeDragSource

-- | Type class for types which can be safely cast to <a>TreeModelSort</a>,
--   for instance with <a>toTreeModelSort</a>.
class (GObject o, IsDescendantOf TreeModelSort o) => IsTreeModelSort o

-- | Memory-managed wrapper type.
newtype () => TreeModelSort
TreeModelSort :: ManagedPtr TreeModelSort -> TreeModelSort

-- | Type class for types which can be safely cast to
--   <a>TreeModelFilter</a>, for instance with <a>toTreeModelFilter</a>.
class (GObject o, IsDescendantOf TreeModelFilter o) => IsTreeModelFilter o

-- | Type class for types which implement <a>TreeDragDest</a>.
class (ManagedPtrNewtype o, IsDescendantOf TreeDragDest o) => IsTreeDragDest o

-- | Type class for types which can be safely cast to <a>TreeStore</a>, for
--   instance with <a>toTreeStore</a>.
class (GObject o, IsDescendantOf TreeStore o) => IsTreeStore o

-- | Type class for types which can be safely cast to <a>ListStore</a>, for
--   instance with <a>toListStore</a>.
class (GObject o, IsDescendantOf ListStore o) => IsListStore o

-- | Type class for types which can be safely cast to <a>ToolShell</a>, for
--   instance with <a>toToolShell</a>.
class (GObject o, IsDescendantOf ToolShell o) => IsToolShell o

-- | Type class for types which can be safely cast to <a>RecentChooser</a>,
--   for instance with <a>toRecentChooser</a>.
class (GObject o, IsDescendantOf RecentChooser o) => IsRecentChooser o

-- | This signal is emitted when there is a change in the set of selected
--   recently used resources. This can happen when a user modifies the
--   selection with the mouse or the keyboard, or when explicitly calling
--   functions to change the selection.
--   
--   <i>Since: 2.10</i>
type RecentChooserSelectionChangedCallback = IO ()

-- | This signal is emitted when the user "activates" a recent item in the
--   recent chooser. This can happen by double-clicking on an item in the
--   recently used resources list, or by pressing <tt>Enter</tt>.
--   
--   <i>Since: 2.10</i>
type RecentChooserItemActivatedCallback = IO ()

-- | Type class for types which can be safely cast to
--   <a>RecentChooserWidget</a>, for instance with
--   <a>toRecentChooserWidget</a>.
class (GObject o, IsDescendantOf RecentChooserWidget o) => IsRecentChooserWidget o

-- | Memory-managed wrapper type.
newtype () => RecentChooserWidget
RecentChooserWidget :: ManagedPtr RecentChooserWidget -> RecentChooserWidget

-- | Type class for types which can be safely cast to
--   <a>RecentChooserDialog</a>, for instance with
--   <a>toRecentChooserDialog</a>.
class (GObject o, IsDescendantOf RecentChooserDialog o) => IsRecentChooserDialog o

-- | Memory-managed wrapper type.
newtype () => RecentChooserDialog
RecentChooserDialog :: ManagedPtr RecentChooserDialog -> RecentChooserDialog

-- | Type class for types which can be safely cast to <a>RecentAction</a>,
--   for instance with <a>toRecentAction</a>.
class (GObject o, IsDescendantOf RecentAction o) => IsRecentAction o

-- | Memory-managed wrapper type.
newtype () => RecentAction
RecentAction :: ManagedPtr RecentAction -> RecentAction

-- | Type class for types which can be safely cast to <a>FileChooser</a>,
--   for instance with <a>toFileChooser</a>.
class (GObject o, IsDescendantOf FileChooser o) => IsFileChooser o

-- | This signal is emitted when the preview in a file chooser should be
--   regenerated. For example, this can happen when the currently selected
--   file changes. You should use this signal if you want your file chooser
--   to have a preview widget.
--   
--   Once you have installed a preview widget with
--   <a>fileChooserSetPreviewWidget</a>, you should update it when this
--   signal is emitted. You can use the functions
--   <a>fileChooserGetPreviewFilename</a> or
--   <a>fileChooserGetPreviewUri</a> to get the name of the file to
--   preview. Your widget may not be able to preview all kinds of files;
--   your callback must call <a>fileChooserSetPreviewWidgetActive</a> to
--   inform the file chooser about whether the preview was generated
--   successfully or not.
--   
--   Please see the example code in [Using a Preview
--   Widget][gtkfilechooser-preview].
--   
--   See also: <a>fileChooserSetPreviewWidget</a>,
--   <a>fileChooserSetPreviewWidgetActive</a>,
--   <a>fileChooserSetUsePreviewLabel</a>,
--   <a>fileChooserGetPreviewFilename</a>, <a>fileChooserGetPreviewUri</a>.
type FileChooserUpdatePreviewCallback = IO ()

-- | This signal is emitted when there is a change in the set of selected
--   files in a <a>FileChooser</a>. This can happen when the user modifies
--   the selection with the mouse or the keyboard, or when explicitly
--   calling functions to change the selection.
--   
--   Normally you do not need to connect to this signal, as it is easier to
--   wait for the file chooser to finish running, and then to get the list
--   of selected files using the functions mentioned below.
--   
--   See also: <a>fileChooserSelectFilename</a>,
--   <a>fileChooserUnselectFilename</a>, <a>fileChooserGetFilename</a>,
--   <a>fileChooserGetFilenames</a>, <a>fileChooserSelectUri</a>,
--   <a>fileChooserUnselectUri</a>, <a>fileChooserGetUri</a>,
--   <a>fileChooserGetUris</a>.
type FileChooserSelectionChangedCallback = IO ()

-- | This signal is emitted when the user "activates" a file in the file
--   chooser. This can happen by double-clicking on a file in the file
--   list, or by pressing <tt>Enter</tt>.
--   
--   Normally you do not need to connect to this signal. It is used
--   internally by <a>FileChooserDialog</a> to know when to activate the
--   default button in the dialog.
--   
--   See also: <a>fileChooserGetFilename</a>,
--   <a>fileChooserGetFilenames</a>, <a>fileChooserGetUri</a>,
--   <a>fileChooserGetUris</a>.
type FileChooserFileActivatedCallback = IO ()

-- | This signal is emitted when the current folder in a <a>FileChooser</a>
--   changes. This can happen due to the user performing some action that
--   changes folders, such as selecting a bookmark or visiting a folder on
--   the file list. It can also happen as a result of calling a function to
--   explicitly change the current folder in a file chooser.
--   
--   Normally you do not need to connect to this signal, unless you need to
--   keep track of which folder a file chooser is showing.
--   
--   See also: <a>fileChooserSetCurrentFolder</a>,
--   <a>fileChooserGetCurrentFolder</a>,
--   <a>fileChooserSetCurrentFolderUri</a>,
--   <a>fileChooserGetCurrentFolderUri</a>.
type FileChooserCurrentFolderChangedCallback = IO ()

-- | This signal gets emitted whenever it is appropriate to present a
--   confirmation dialog when the user has selected a file name that
--   already exists. The signal only gets emitted when the file chooser is
--   in <a>FileChooserActionSave</a> mode.
--   
--   Most applications just need to turn on the
--   <a>FileChooser</a>:<tt><i>do-overwrite-confirmation</i></tt> property
--   (or call the <a>fileChooserSetDoOverwriteConfirmation</a> function),
--   and they will automatically get a stock confirmation dialog.
--   Applications which need to customize this behavior should do that, and
--   also connect to the <a>FileChooser::confirmOverwrite</a> signal.
--   
--   A signal handler for this signal must return a
--   <a>FileChooserConfirmation</a> value, which indicates the action to
--   take. If the handler determines that the user wants to select a
--   different filename, it should return
--   <a>FileChooserConfirmationSelectAgain</a>. If it determines that the
--   user is satisfied with his choice of file name, it should return
--   <a>FileChooserConfirmationAcceptFilename</a>. On the other hand, if it
--   determines that the stock confirmation dialog should be used, it
--   should return <a>FileChooserConfirmationConfirm</a>. The following
--   example illustrates this.
--   
--   ## Custom confirmation ##
--   {<tt><i>gtkfilechooser</i></tt>-confirmation}
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   static GtkFileChooserConfirmation
--   confirm_overwrite_callback (GtkFileChooser *chooser, gpointer data)
--   {
--     char *uri;
--   
--     uri = gtk_file_chooser_get_uri (chooser);
--   
--     if (is_uri_read_only (uri))
--       {
--         if (user_wants_to_replace_read_only_file (uri))
--           return GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME;
--         else
--           return GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN;
--       } else
--         return GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM; // fall back to the default dialog
--   }
--   
--   ...
--   
--   chooser = gtk_file_chooser_dialog_new (...);
--   
--   gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
--   g_signal_connect (chooser, "confirm-overwrite",
--                     G_CALLBACK (confirm_overwrite_callback), NULL);
--   
--   if (gtk_dialog_run (chooser) == GTK_RESPONSE_ACCEPT)
--           save_to_file (gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser));
--   
--   gtk_widget_destroy (chooser);
--   </pre>
--   
--   <i>Since: 2.8</i>
type FileChooserConfirmOverwriteCallback = IO FileChooserConfirmation

-- | Type class for types which can be safely cast to
--   <a>FileChooserWidget</a>, for instance with
--   <a>toFileChooserWidget</a>.
class (GObject o, IsDescendantOf FileChooserWidget o) => IsFileChooserWidget o

-- | Memory-managed wrapper type.
newtype () => FileChooserWidget
FileChooserWidget :: ManagedPtr FileChooserWidget -> FileChooserWidget

-- | The <a>upFolder</a> signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted when the user asks for it.
--   
--   This is used to make the file chooser go to the parent of the current
--   folder in the file hierarchy.
--   
--   The default binding for this signal is <tt>Alt + Up</tt>.
type FileChooserWidgetUpFolderCallback = IO ()

-- | The <a>showHidden</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user asks for
--   it.
--   
--   This is used to make the file chooser display hidden files.
--   
--   The default binding for this signal is <tt>Control + H</tt>.
type FileChooserWidgetShowHiddenCallback = IO ()

-- | The <a>searchShortcut</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user asks for
--   it.
--   
--   This is used to make the file chooser show the search entry.
--   
--   The default binding for this signal is <tt>Alt + S</tt>.
type FileChooserWidgetSearchShortcutCallback = IO ()

-- | The <a>recentShortcut</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user asks for
--   it.
--   
--   This is used to make the file chooser show the Recent location.
--   
--   The default binding for this signal is <tt>Alt + R</tt>.
type FileChooserWidgetRecentShortcutCallback = IO ()

-- | The <a>quickBookmark</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user asks for
--   it.
--   
--   This is used to make the file chooser switch to the bookmark specified
--   in the <i><tt>bookmarkIndex</tt></i> parameter. For example, if you
--   have three bookmarks, you can pass 0, 1, 2 to this signal to switch to
--   each of them, respectively.
--   
--   The default binding for this signal is <tt>Alt + 1</tt>, <tt>Alt +
--   2</tt>, etc. until <tt>Alt + 0</tt>. Note that in the default binding,
--   that <tt>Alt + 1</tt> is actually defined to switch to the bookmark at
--   index 0, and so on successively; <tt>Alt + 0</tt> is defined to switch
--   to the bookmark at index 10.
type FileChooserWidgetQuickBookmarkCallback = Int32 -> IO ()

-- | The <a>placesShortcut</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user asks for
--   it.
--   
--   This is used to move the focus to the places sidebar.
--   
--   The default binding for this signal is <tt>Alt + P</tt>.
type FileChooserWidgetPlacesShortcutCallback = IO ()

-- | The <a>locationTogglePopup</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user asks for
--   it.
--   
--   This is used to toggle the visibility of a "Location" prompt which the
--   user can use to manually type the name of the file he wishes to
--   select.
--   
--   The default binding for this signal is <tt>Control + L</tt>.
type FileChooserWidgetLocationTogglePopupCallback = IO ()

-- | The <a>locationPopupOnPaste</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user asks for
--   it.
--   
--   This is used to make the file chooser show a "Location" prompt when
--   the user pastes into a <a>FileChooserWidget</a>.
--   
--   The default binding for this signal is <tt>Control + V</tt>.
type FileChooserWidgetLocationPopupOnPasteCallback = IO ()

-- | The <a>locationPopup</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user asks for
--   it.
--   
--   This is used to make the file chooser show a "Location" prompt which
--   the user can use to manually type the name of the file he wishes to
--   select.
--   
--   The default bindings for this signal are <tt>Control + L</tt> with a
--   <i><tt>path</tt></i> string of "" (the empty string). It is also bound
--   to <tt>/</tt> with a <i><tt>path</tt></i> string of "<tt>/</tt>" (a
--   slash): this lets you type <tt>/</tt> and immediately type a path
--   name. On Unix systems, this is bound to <tt>~</tt> (tilde) with a
--   <i><tt>path</tt></i> string of "~" itself for access to home
--   directories.
type FileChooserWidgetLocationPopupCallback = Text -> IO ()

-- | The <a>homeFolder</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user asks for
--   it.
--   
--   This is used to make the file chooser show the user's home folder in
--   the file list.
--   
--   The default binding for this signal is <tt>Alt + Home</tt>.
type FileChooserWidgetHomeFolderCallback = IO ()

-- | The <a>downFolder</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user asks for
--   it.
--   
--   This is used to make the file chooser go to a child of the current
--   folder in the file hierarchy. The subfolder that will be used is
--   displayed in the path bar widget of the file chooser. For example, if
--   the path bar is showing "/foo/bar/baz", with bar currently displayed,
--   then this will cause the file chooser to switch to the "baz"
--   subfolder.
--   
--   The default binding for this signal is <tt>Alt + Down</tt>.
type FileChooserWidgetDownFolderCallback = IO ()

-- | The <a>desktopFolder</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user asks for
--   it.
--   
--   This is used to make the file chooser show the user's Desktop folder
--   in the file list.
--   
--   The default binding for this signal is <tt>Alt + D</tt>.
type FileChooserWidgetDesktopFolderCallback = IO ()

-- | Type class for types which can be safely cast to
--   <a>FileChooserNative</a>, for instance with
--   <a>toFileChooserNative</a>.
class (GObject o, IsDescendantOf FileChooserNative o) => IsFileChooserNative o

-- | Memory-managed wrapper type.
newtype () => FileChooserNative
FileChooserNative :: ManagedPtr FileChooserNative -> FileChooserNative

-- | Type class for types which can be safely cast to
--   <a>FileChooserDialog</a>, for instance with
--   <a>toFileChooserDialog</a>.
class (GObject o, IsDescendantOf FileChooserDialog o) => IsFileChooserDialog o

-- | Type class for types which can be safely cast to
--   <a>FileChooserButton</a>, for instance with
--   <a>toFileChooserButton</a>.
class (GObject o, IsDescendantOf FileChooserButton o) => IsFileChooserButton o

-- | Memory-managed wrapper type.
newtype () => FileChooserButton
FileChooserButton :: ManagedPtr FileChooserButton -> FileChooserButton

-- | The <a>fileSet</a> signal is emitted when the user selects a file.
--   
--   Note that this signal is only emitted when the user changes the file.
--   
--   <i>Since: 2.12</i>
type FileChooserButtonFileSetCallback = IO ()

-- | Type class for types which can be safely cast to
--   <a>RendererCellAccessible</a>, for instance with
--   <a>toRendererCellAccessible</a>.
class (GObject o, IsDescendantOf RendererCellAccessible o) => IsRendererCellAccessible o

-- | Memory-managed wrapper type.
newtype () => RendererCellAccessible
RendererCellAccessible :: ManagedPtr RendererCellAccessible -> RendererCellAccessible

-- | Type class for types which can be safely cast to
--   <a>TextCellAccessible</a>, for instance with
--   <a>toTextCellAccessible</a>.
class (GObject o, IsDescendantOf TextCellAccessible o) => IsTextCellAccessible o

-- | Memory-managed wrapper type.
newtype () => TextCellAccessible
TextCellAccessible :: ManagedPtr TextCellAccessible -> TextCellAccessible

-- | Type class for types which can be safely cast to
--   <a>ImageCellAccessible</a>, for instance with
--   <a>toImageCellAccessible</a>.
class (GObject o, IsDescendantOf ImageCellAccessible o) => IsImageCellAccessible o

-- | Memory-managed wrapper type.
newtype () => ImageCellAccessible
ImageCellAccessible :: ManagedPtr ImageCellAccessible -> ImageCellAccessible

-- | Type class for types which can be safely cast to
--   <a>CellRendererToggle</a>, for instance with
--   <a>toCellRendererToggle</a>.
class (GObject o, IsDescendantOf CellRendererToggle o) => IsCellRendererToggle o

-- | The <a>toggled</a> signal is emitted when the cell is toggled.
--   
--   It is the responsibility of the application to update the model with
--   the correct value to store at <i><tt>path</tt></i>. Often this is
--   simply the opposite of the value currently stored at
--   <i><tt>path</tt></i>.
type CellRendererToggleToggledCallback = Text -> IO ()

-- | Type class for types which can be safely cast to
--   <a>CellRendererText</a>, for instance with <a>toCellRendererText</a>.
class (GObject o, IsDescendantOf CellRendererText o) => IsCellRendererText o

-- | This signal is emitted after <i><tt>renderer</tt></i> has been edited.
--   
--   It is the responsibility of the application to update the model and
--   store <i><tt>newText</tt></i> at the position indicated by
--   <i><tt>path</tt></i>.
type CellRendererTextEditedCallback = Text -> Text -> IO ()

-- | Type class for types which can be safely cast to
--   <a>CellRendererSpinner</a>, for instance with
--   <a>toCellRendererSpinner</a>.
class (GObject o, IsDescendantOf CellRendererSpinner o) => IsCellRendererSpinner o

-- | Memory-managed wrapper type.
newtype () => CellRendererSpinner
CellRendererSpinner :: ManagedPtr CellRendererSpinner -> CellRendererSpinner

-- | Type class for types which can be safely cast to
--   <a>CellRendererSpin</a>, for instance with <a>toCellRendererSpin</a>.
class (GObject o, IsDescendantOf CellRendererSpin o) => IsCellRendererSpin o

-- | Memory-managed wrapper type.
newtype () => CellRendererSpin
CellRendererSpin :: ManagedPtr CellRendererSpin -> CellRendererSpin

-- | Type class for types which can be safely cast to
--   <a>CellRendererProgress</a>, for instance with
--   <a>toCellRendererProgress</a>.
class (GObject o, IsDescendantOf CellRendererProgress o) => IsCellRendererProgress o

-- | Memory-managed wrapper type.
newtype () => CellRendererProgress
CellRendererProgress :: ManagedPtr CellRendererProgress -> CellRendererProgress

-- | Type class for types which can be safely cast to
--   <a>CellRendererPixbuf</a>, for instance with
--   <a>toCellRendererPixbuf</a>.
class (GObject o, IsDescendantOf CellRendererPixbuf o) => IsCellRendererPixbuf o

-- | Type class for types which can be safely cast to
--   <a>CellRendererCombo</a>, for instance with
--   <a>toCellRendererCombo</a>.
class (GObject o, IsDescendantOf CellRendererCombo o) => IsCellRendererCombo o

-- | Memory-managed wrapper type.
newtype () => CellRendererCombo
CellRendererCombo :: ManagedPtr CellRendererCombo -> CellRendererCombo

-- | This signal is emitted each time after the user selected an item in
--   the combo box, either by using the mouse or the arrow keys. Contrary
--   to GtkComboBox, GtkCellRendererCombo<a>changed</a> is not emitted for
--   changes made to a selected item in the entry. The argument
--   <i><tt>newIter</tt></i> corresponds to the newly selected item in the
--   combo box and it is relative to the GtkTreeModel set via the model
--   property on GtkCellRendererCombo.
--   
--   Note that as soon as you change the model displayed in the tree view,
--   the tree view will immediately cease the editing operating. This means
--   that you most probably want to refrain from changing the model until
--   the combo cell renderer emits the edited or editing_canceled signal.
--   
--   <i>Since: 2.14</i>
type CellRendererComboChangedCallback = Text -> TreeIter -> IO ()

-- | Type class for types which can be safely cast to
--   <a>CellRendererAccel</a>, for instance with
--   <a>toCellRendererAccel</a>.
class (GObject o, IsDescendantOf CellRendererAccel o) => IsCellRendererAccel o

-- | Memory-managed wrapper type.
newtype () => CellRendererAccel
CellRendererAccel :: ManagedPtr CellRendererAccel -> CellRendererAccel

-- | Gets emitted when the user has selected a new accelerator.
--   
--   <i>Since: 2.10</i>
type CellRendererAccelAccelEditedCallback = Text -> Word32 -> [ModifierType] -> Word32 -> IO ()

-- | Gets emitted when the user has removed the accelerator.
--   
--   <i>Since: 2.10</i>
type CellRendererAccelAccelClearedCallback = Text -> IO ()

-- | Type class for types which can be safely cast to
--   <a>BooleanCellAccessible</a>, for instance with
--   <a>toBooleanCellAccessible</a>.
class (GObject o, IsDescendantOf BooleanCellAccessible o) => IsBooleanCellAccessible o

-- | Memory-managed wrapper type.
newtype () => BooleanCellAccessible
BooleanCellAccessible :: ManagedPtr BooleanCellAccessible -> BooleanCellAccessible

-- | Type class for types which can be safely cast to <a>SpinButton</a>,
--   for instance with <a>toSpinButton</a>.
class (GObject o, IsDescendantOf SpinButton o) => IsSpinButton o

-- | The <a>wrapped</a> signal is emitted right after the spinbutton wraps
--   from its maximum to minimum value or vice-versa.
--   
--   <i>Since: 2.10</i>
type SpinButtonWrappedCallback = IO ()

-- | The <a>valueChanged</a> signal is emitted when the value represented
--   by <i><tt>spinbutton</tt></i> changes. Also see the
--   <a>SpinButton::output</a> signal.
type SpinButtonValueChangedCallback = IO ()

-- | The <a>output</a> signal can be used to change to formatting of the
--   value that is displayed in the spin buttons entry.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   // show leading zeros
--   static gboolean
--   on_output (GtkSpinButton *spin,
--              gpointer       data)
--   {
--      GtkAdjustment *adjustment;
--      gchar *text;
--      int value;
--   
--      adjustment = gtk_spin_button_get_adjustment (spin);
--      value = (int)gtk_adjustment_get_value (adjustment);
--      text = g_strdup_printf ("%02d", value);
--      gtk_entry_set_text (GTK_ENTRY (spin), text);
--      g_free (text);
--   
--      return TRUE;
--   }
--   </pre>
type SpinButtonOutputCallback = IO Bool

-- | The <a>input</a> signal can be used to influence the conversion of the
--   users input into a double value. The signal handler is expected to use
--   <a>entryGetText</a> to retrieve the text of the entry and set
--   <i><tt>newValue</tt></i> to the new value.
--   
--   The default conversion uses <a>strtod</a>.
type SpinButtonInputCallback = IO (Int32, Double)

-- | The <a>changeValue</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user initiates a
--   value change.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control the
--   cursor programmatically.
--   
--   The default bindings for this signal are Up/Down and PageUp
--   and/PageDown.
type SpinButtonChangeValueCallback = ScrollType -> IO ()

-- | Type class for types which can be safely cast to <a>SearchEntry</a>,
--   for instance with <a>toSearchEntry</a>.
class (GObject o, IsDescendantOf SearchEntry o) => IsSearchEntry o

-- | Memory-managed wrapper type.
newtype () => SearchEntry
SearchEntry :: ManagedPtr SearchEntry -> SearchEntry

-- | The <a>stopSearch</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user stops a
--   search via keyboard input.
--   
--   Applications should connect to it, to implement hiding the search
--   entry in this case.
--   
--   The default bindings for this signal is Escape.
--   
--   <i>Since: 3.16</i>
type SearchEntryStopSearchCallback = IO ()

-- | The <a>SearchEntry::searchChanged</a> signal is emitted with a short
--   delay of 150 milliseconds after the last change to the entry text.
--   
--   <i>Since: 3.10</i>
type SearchEntrySearchChangedCallback = IO ()

-- | The <a>previousMatch</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user initiates a
--   move to the previous match for the current search string.
--   
--   Applications should connect to it, to implement moving between
--   matches.
--   
--   The default bindings for this signal is Ctrl-Shift-g.
--   
--   <i>Since: 3.16</i>
type SearchEntryPreviousMatchCallback = IO ()

-- | The <a>nextMatch</a> signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted when the user initiates a move to the next match
--   for the current search string.
--   
--   Applications should connect to it, to implement moving between
--   matches.
--   
--   The default bindings for this signal is Ctrl-g.
--   
--   <i>Since: 3.16</i>
type SearchEntryNextMatchCallback = IO ()

-- | Type class for types which can be safely cast to <a>SearchBar</a>, for
--   instance with <a>toSearchBar</a>.
class (GObject o, IsDescendantOf SearchBar o) => IsSearchBar o

-- | Type class for types which can be safely cast to <a>ComboBox</a>, for
--   instance with <a>toComboBox</a>.
class (GObject o, IsDescendantOf ComboBox o) => IsComboBox o

-- | The <a>popup</a> signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted to popup the combo box list.
--   
--   The default binding for this signal is Alt+Down.
--   
--   <i>Since: 2.12</i>
type ComboBoxPopupCallback = IO ()

-- | The <a>popdown</a> signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted to popdown the combo box list.
--   
--   The default bindings for this signal are Alt+Up and Escape.
--   
--   <i>Since: 2.12</i>
type ComboBoxPopdownCallback = IO Bool

-- | The <a>moveActive</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to move the active
--   selection.
--   
--   <i>Since: 2.12</i>
type ComboBoxMoveActiveCallback = ScrollType -> IO ()

-- | For combo boxes that are created with an entry (See
--   GtkComboBox:has-entry).
--   
--   A signal which allows you to change how the text displayed in a combo
--   box's entry is displayed.
--   
--   Connect a signal handler which returns an allocated string
--   representing <i><tt>path</tt></i>. That string will then be used to
--   set the text in the combo box's entry. The default signal handler uses
--   the text from the GtkComboBox<a>entryTextColumn</a> model column.
--   
--   Here's an example signal handler which fetches data from the model and
--   displays it in the entry.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   static gchar*
--   format_entry_text_callback (GtkComboBox *combo,
--                               const gchar *path,
--                               gpointer     user_data)
--   {
--     GtkTreeIter iter;
--     GtkTreeModel model;
--     gdouble      value;
--   
--     model = gtk_combo_box_get_model (combo);
--   
--     gtk_tree_model_get_iter_from_string (model, &amp;iter, path);
--     gtk_tree_model_get (model, &amp;iter,
--                         THE_DOUBLE_VALUE_COLUMN, &amp;value,
--                         -1);
--   
--     return g_strdup_printf ("%g", value);
--   }
--   </pre>
--   
--   <i>Since: 3.4</i>
type ComboBoxFormatEntryTextCallback = Text -> IO Text

-- | The changed signal is emitted when the active item is changed. The can
--   be due to the user selecting a different item from the list, or due to
--   a call to <a>comboBoxSetActiveIter</a>. It will also be emitted while
--   typing into the entry of a combo box with an entry.
--   
--   <i>Since: 2.4</i>
type ComboBoxChangedCallback = IO ()

-- | Type class for types which can be safely cast to <a>ComboBoxText</a>,
--   for instance with <a>toComboBoxText</a>.
class (GObject o, IsDescendantOf ComboBoxText o) => IsComboBoxText o

-- | Memory-managed wrapper type.
newtype () => ComboBoxText
ComboBoxText :: ManagedPtr ComboBoxText -> ComboBoxText

-- | Type class for types which can be safely cast to <a>CellView</a>, for
--   instance with <a>toCellView</a>.
class (GObject o, IsDescendantOf CellView o) => IsCellView o

-- | Memory-managed wrapper type.
newtype () => CellView
CellView :: ManagedPtr CellView -> CellView

-- | Type class for types which can be safely cast to <a>CellAreaBox</a>,
--   for instance with <a>toCellAreaBox</a>.
class (GObject o, IsDescendantOf CellAreaBox o) => IsCellAreaBox o

-- | Memory-managed wrapper type.
newtype () => CellAreaBox
CellAreaBox :: ManagedPtr CellAreaBox -> CellAreaBox

-- | Type class for types which implement <a>CellAccessibleParent</a>.
class (ManagedPtrNewtype o, IsDescendantOf CellAccessibleParent o) => IsCellAccessibleParent o

-- | Memory-managed wrapper type.
newtype () => CellAccessibleParent
CellAccessibleParent :: ManagedPtr CellAccessibleParent -> CellAccessibleParent

-- | Type class for types which can be safely cast to
--   <a>TreeViewAccessible</a>, for instance with
--   <a>toTreeViewAccessible</a>.
class (GObject o, IsDescendantOf TreeViewAccessible o) => IsTreeViewAccessible o

-- | Memory-managed wrapper type.
newtype () => TreeViewAccessible
TreeViewAccessible :: ManagedPtr TreeViewAccessible -> TreeViewAccessible

-- | Type class for types which can be safely cast to <a>AppChooser</a>,
--   for instance with <a>toAppChooser</a>.
class (GObject o, IsDescendantOf AppChooser o) => IsAppChooser o

-- | Memory-managed wrapper type.
newtype () => AppChooser
AppChooser :: ManagedPtr AppChooser -> AppChooser

-- | Type class for types which can be safely cast to
--   <a>AppChooserDialog</a>, for instance with <a>toAppChooserDialog</a>.
class (GObject o, IsDescendantOf AppChooserDialog o) => IsAppChooserDialog o

-- | Type class for types which can be safely cast to
--   <a>AppChooserButton</a>, for instance with <a>toAppChooserButton</a>.
class (GObject o, IsDescendantOf AppChooserButton o) => IsAppChooserButton o

-- | Memory-managed wrapper type.
newtype () => AppChooserButton
AppChooserButton :: ManagedPtr AppChooserButton -> AppChooserButton

-- | Emitted when a custom item, previously added with
--   <a>appChooserButtonAppendCustomItem</a>, is activated from the
--   dropdown menu.
type AppChooserButtonCustomItemActivatedCallback = Text -> IO ()

-- | Type class for types which can be safely cast to <a>ToolItem</a>, for
--   instance with <a>toToolItem</a>.
class (GObject o, IsDescendantOf ToolItem o) => IsToolItem o

-- | This signal is emitted when some property of the toolbar that the item
--   is a child of changes. For custom subclasses of <a>ToolItem</a>, the
--   default handler of this signal use the functions
--   
--   <ul>
--   <li><a>toolShellGetOrientation</a></li>
--   <li><a>toolShellGetStyle</a></li>
--   <li><a>toolShellGetIconSize</a></li>
--   <li><a>toolShellGetReliefStyle</a></li>
--   </ul>
--   
--   to find out what the toolbar should look like and change themselves
--   accordingly.
type ToolItemToolbarReconfiguredCallback = IO ()

-- | This signal is emitted when the toolbar needs information from
--   <i><tt>toolItem</tt></i> about whether the item should appear in the
--   toolbar overflow menu. In response the tool item should either
--   
--   <ul>
--   <li>call <a>toolItemSetProxyMenuItem</a> with a <a>Nothing</a> pointer
--   and return <a>True</a> to indicate that the item should not appear in
--   the overflow menu</li>
--   <li>call <a>toolItemSetProxyMenuItem</a> with a new menu item and
--   return <a>True</a>, or</li>
--   <li>return <a>False</a> to indicate that the signal was not handled by
--   the item. This means that the item will not appear in the overflow
--   menu unless a later handler installs a menu item.</li>
--   </ul>
--   
--   The toolbar may cache the result of this signal. When the tool item
--   changes how it will respond to this signal it must call
--   <a>toolItemRebuildMenu</a> to invalidate the cache and ensure that the
--   toolbar rebuilds its overflow menu.
type ToolItemCreateMenuProxyCallback = IO Bool

-- | Type class for types which can be safely cast to <a>Toolbar</a>, for
--   instance with <a>toToolbar</a>.
class (GObject o, IsDescendantOf Toolbar o) => IsToolbar o

-- | Emitted when the style of the toolbar changes.
type ToolbarStyleChangedCallback = ToolbarStyle -> IO ()

-- | Emitted when the user right-clicks the toolbar or uses the keybinding
--   to display a popup menu.
--   
--   Application developers should handle this signal if they want to
--   display a context menu on the toolbar. The context-menu should appear
--   at the coordinates given by <i><tt>x</tt></i> and <i><tt>y</tt></i>.
--   The mouse button number is given by the <i><tt>button</tt></i>
--   parameter. If the menu was popped up using the keybaord,
--   <i><tt>button</tt></i> is -1.
type ToolbarPopupContextMenuCallback = Int32 -> Int32 -> Int32 -> IO Bool

-- | Emitted when the orientation of the toolbar changes.
type ToolbarOrientationChangedCallback = Orientation -> IO ()

-- | A keybinding signal used internally by GTK+. This signal can't be used
--   in application code
type ToolbarFocusHomeOrEndCallback = Bool -> IO Bool

-- | Type class for types which can be safely cast to <a>ToolItemGroup</a>,
--   for instance with <a>toToolItemGroup</a>.
class (GObject o, IsDescendantOf ToolItemGroup o) => IsToolItemGroup o

-- | Type class for types which can be safely cast to <a>ToolPalette</a>,
--   for instance with <a>toToolPalette</a>.
class (GObject o, IsDescendantOf ToolPalette o) => IsToolPalette o

-- | Memory-managed wrapper type.
newtype () => ToolPalette
ToolPalette :: ManagedPtr ToolPalette -> ToolPalette

-- | Type class for types which can be safely cast to
--   <a>SeparatorToolItem</a>, for instance with
--   <a>toSeparatorToolItem</a>.
class (GObject o, IsDescendantOf SeparatorToolItem o) => IsSeparatorToolItem o

-- | Memory-managed wrapper type.
newtype () => SeparatorToolItem
SeparatorToolItem :: ManagedPtr SeparatorToolItem -> SeparatorToolItem

-- | Type class for types which can be safely cast to <a>ToolButton</a>,
--   for instance with <a>toToolButton</a>.
class (GObject o, IsDescendantOf ToolButton o) => IsToolButton o

-- | This signal is emitted when the tool button is clicked with the mouse
--   or activated with the keyboard.
type ToolButtonClickedCallback = IO ()

-- | Type class for types which can be safely cast to
--   <a>ToggleToolButton</a>, for instance with <a>toToggleToolButton</a>.
class (GObject o, IsDescendantOf ToggleToolButton o) => IsToggleToolButton o

-- | Memory-managed wrapper type.
newtype () => ToggleToolButton
ToggleToolButton :: ManagedPtr ToggleToolButton -> ToggleToolButton

-- | Emitted whenever the toggle tool button changes state.
type ToggleToolButtonToggledCallback = IO ()

-- | Type class for types which can be safely cast to <a>Switch</a>, for
--   instance with <a>toSwitch</a>.
class (GObject o, IsDescendantOf Switch o) => IsSwitch o

-- | Memory-managed wrapper type.
newtype () => Switch
Switch :: ManagedPtr Switch -> Switch

-- | The <a>stateSet</a> signal on GtkSwitch is emitted to change the
--   underlying state. It is emitted when the user changes the switch
--   position. The default handler keeps the state in sync with the
--   <a>Switch:active</a> property.
--   
--   To implement delayed state change, applications can connect to this
--   signal, initiate the change of the underlying state, and call
--   <a>switchSetState</a> when the underlying state change is complete.
--   The signal handler should return <a>True</a> to prevent the default
--   handler from running.
--   
--   Visually, the underlying state is represented by the trough color of
--   the switch, while the <a>Switch:active</a> property is represented by
--   the position of the switch.
--   
--   <i>Since: 3.14</i>
type SwitchStateSetCallback = Bool -> IO Bool

-- | The <a>activate</a> signal on GtkSwitch is an action signal and
--   emitting it causes the switch to animate. Applications should never
--   connect to this signal, but use the notify<a>active</a> signal.
type SwitchActivateCallback = IO ()

-- | Type class for types which can be safely cast to
--   <a>TearoffMenuItem</a>, for instance with <a>toTearoffMenuItem</a>.
class (GObject o, IsDescendantOf TearoffMenuItem o) => IsTearoffMenuItem o

-- | Memory-managed wrapper type.
newtype () => TearoffMenuItem
TearoffMenuItem :: ManagedPtr TearoffMenuItem -> TearoffMenuItem

-- | Type class for types which can be safely cast to <a>StatusIcon</a>,
--   for instance with <a>toStatusIcon</a>.
class (GObject o, IsDescendantOf StatusIcon o) => IsStatusIcon o

-- | Memory-managed wrapper type.
newtype () => StatusIcon
StatusIcon :: ManagedPtr StatusIcon -> StatusIcon

-- | Gets emitted when the size available for the image changes, e.g.
--   because the notification area got resized.
--   
--   <i>Since: 2.10</i>
type StatusIconSizeChangedCallback = Int32 -> IO Bool

-- | The <a>scrollEvent</a> signal is emitted when a button in the 4 to 7
--   range is pressed. Wheel mice are usually configured to generate button
--   press events for buttons 4 and 5 when the wheel is turned.
--   
--   Whether this event is emitted is platform-dependent.
--   
--   <i>Since: 2.16</i>
type StatusIconScrollEventCallback = EventScroll -> IO Bool

-- | Emitted when the hover timeout has expired with the cursor hovering
--   above <i><tt>statusIcon</tt></i>; or emitted when
--   <i><tt>statusIcon</tt></i> got focus in keyboard mode.
--   
--   Using the given coordinates, the signal handler should determine
--   whether a tooltip should be shown for <i><tt>statusIcon</tt></i>. If
--   this is the case <a>True</a> should be returned, <a>False</a>
--   otherwise. Note that if <i><tt>keyboardMode</tt></i> is <a>True</a>,
--   the values of <i><tt>x</tt></i> and <i><tt>y</tt></i> are undefined
--   and should not be used.
--   
--   The signal handler is free to manipulate <i><tt>tooltip</tt></i> with
--   the therefore destined function calls.
--   
--   Whether this signal is emitted is platform-dependent. For plain text
--   tooltips, use <a>StatusIcon:tooltipText</a> in preference.
--   
--   <i>Since: 2.16</i>
type StatusIconQueryTooltipCallback = Int32 -> Int32 -> Bool -> Tooltip -> IO Bool

-- | Gets emitted when the user brings up the context menu of the status
--   icon. Whether status icons can have context menus and how these are
--   activated is platform-dependent.
--   
--   The <i><tt>button</tt></i> and <i><tt>activateTime</tt></i> parameters
--   should be passed as the last to arguments to <a>menuPopup</a>.
--   
--   Unlike most G_SIGNAL_ACTION signals, this signal is meant to be used
--   by applications and should be wrapped by language bindings.
--   
--   <i>Since: 2.10</i>
type StatusIconPopupMenuCallback = Word32 -> Word32 -> IO ()

-- | The <a>buttonReleaseEvent</a> signal will be emitted when a button
--   (typically from a mouse) is released.
--   
--   Whether this event is emitted is platform-dependent. Use the
--   <a>activate</a> and <a>popupMenu</a> signals in preference.
--   
--   <i>Since: 2.14</i>
type StatusIconButtonReleaseEventCallback = EventButton -> IO Bool

-- | The <a>buttonPressEvent</a> signal will be emitted when a button
--   (typically from a mouse) is pressed.
--   
--   Whether this event is emitted is platform-dependent. Use the
--   <a>activate</a> and <a>popupMenu</a> signals in preference.
--   
--   <i>Since: 2.14</i>
type StatusIconButtonPressEventCallback = EventButton -> IO Bool

-- | Gets emitted when the user activates the status icon. If and how
--   status icons can activated is platform-dependent.
--   
--   Unlike most G_SIGNAL_ACTION signals, this signal is meant to be used
--   by applications and should be wrapped by language bindings.
--   
--   <i>Since: 2.10</i>
type StatusIconActivateCallback = IO ()

-- | Type class for types which can be safely cast to
--   <a>SeparatorMenuItem</a>, for instance with
--   <a>toSeparatorMenuItem</a>.
class (GObject o, IsDescendantOf SeparatorMenuItem o) => IsSeparatorMenuItem o

-- | Memory-managed wrapper type.
newtype () => SeparatorMenuItem
SeparatorMenuItem :: ManagedPtr SeparatorMenuItem -> SeparatorMenuItem

-- | Type class for types which can be safely cast to
--   <a>RecentChooserMenu</a>, for instance with
--   <a>toRecentChooserMenu</a>.
class (GObject o, IsDescendantOf RecentChooserMenu o) => IsRecentChooserMenu o

-- | Memory-managed wrapper type.
newtype () => RecentChooserMenu
RecentChooserMenu :: ManagedPtr RecentChooserMenu -> RecentChooserMenu

-- | Type class for types which can be safely cast to
--   <a>MenuToolButton</a>, for instance with <a>toMenuToolButton</a>.
class (GObject o, IsDescendantOf MenuToolButton o) => IsMenuToolButton o

-- | Memory-managed wrapper type.
newtype () => MenuToolButton
MenuToolButton :: ManagedPtr MenuToolButton -> MenuToolButton

-- | The <a>showMenu</a> signal is emitted before the menu is shown.
--   
--   It can be used to populate the menu on demand, using
--   <a>menuToolButtonSetMenu</a>.
--   
--   Note that even if you populate the menu dynamically in this way, you
--   must set an empty menu on the <a>MenuToolButton</a> beforehand, since
--   the arrow is made insensitive if the menu is not set.
type MenuToolButtonShowMenuCallback = IO ()

-- | Type class for types which can be safely cast to <a>MenuBar</a>, for
--   instance with <a>toMenuBar</a>.
class (GObject o, IsDescendantOf MenuBar o) => IsMenuBar o

-- | The <a>populatePopup</a> signal gets emitted before showing the
--   context menu of the label. Note that only selectable labels have
--   context menus.
--   
--   If you need to add items to the context menu, connect to this signal
--   and append your menuitems to the <i><tt>menu</tt></i>.
type LabelPopulatePopupCallback = Menu -> IO ()

-- | The <a>moveCursor</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted when the user initiates a
--   cursor movement. If the cursor is not visible in
--   <i><tt>entry</tt></i>, this signal causes the viewport to be moved
--   instead.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control the
--   cursor programmatically.
--   
--   The default bindings for this signal come in two variants, the variant
--   with the Shift modifier extends the selection, the variant without the
--   Shift modifer does not. There are too many key combinations to list
--   them all here.
--   
--   <ul>
--   <li>Arrow keys move by individual characters/lines</li>
--   <li>Ctrl-arrow key combinations move by words/paragraphs</li>
--   <li>Home/End keys move to the ends of the buffer</li>
--   </ul>
type LabelMoveCursorCallback = MovementStep -> Int32 -> Bool -> IO ()

-- | The <a>copyClipboard</a> signal is a [keybinding
--   signal][GtkBindingSignal] which gets emitted to copy the selection to
--   the clipboard.
--   
--   The default binding for this signal is Ctrl-c.
type LabelCopyClipboardCallback = IO ()

-- | The signal which gets emitted to activate a URI. Applications may
--   connect to it to override the default behaviour, which is to call
--   <a>showUriOnWindow</a>.
--   
--   <i>Since: 2.18</i>
type LabelActivateLinkCallback = Text -> IO Bool

-- | A [keybinding signal][GtkBindingSignal] which gets emitted when the
--   user activates a link in the label.
--   
--   Applications may also emit the signal with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control
--   activation of URIs programmatically.
--   
--   The default bindings for this signal are all forms of the Enter key.
--   
--   <i>Since: 2.18</i>
type LabelActivateCurrentLinkCallback = IO ()

-- | Type class for types which can be safely cast to <a>ImageMenuItem</a>,
--   for instance with <a>toImageMenuItem</a>.
class (GObject o, IsDescendantOf ImageMenuItem o) => IsImageMenuItem o

-- | Memory-managed wrapper type.
newtype () => ImageMenuItem
ImageMenuItem :: ManagedPtr ImageMenuItem -> ImageMenuItem

-- | Type class for types which can be safely cast to
--   <a>IMMulticontext</a>, for instance with <a>toIMMulticontext</a>.
class (GObject o, IsDescendantOf IMMulticontext o) => IsIMMulticontext o

-- | Memory-managed wrapper type.
newtype () => IMMulticontext
IMMulticontext :: ManagedPtr IMMulticontext -> IMMulticontext

-- | Type class for types which can be safely cast to <a>CheckMenuItem</a>,
--   for instance with <a>toCheckMenuItem</a>.
class (GObject o, IsDescendantOf CheckMenuItem o) => IsCheckMenuItem o

-- | Memory-managed wrapper type.
newtype () => CheckMenuItem
CheckMenuItem :: ManagedPtr CheckMenuItem -> CheckMenuItem

-- | This signal is emitted when the state of the check box is changed.
--   
--   A signal handler can use <a>checkMenuItemGetActive</a> to discover the
--   new state.
type CheckMenuItemToggledCallback = IO ()

-- | Type class for types which can be safely cast to <a>RadioMenuItem</a>,
--   for instance with <a>toRadioMenuItem</a>.
class (GObject o, IsDescendantOf RadioMenuItem o) => IsRadioMenuItem o

-- | <i>No description available in the introspection data.</i>
type RadioMenuItemGroupChangedCallback = IO ()

-- | Type class for types which can be safely cast to <a>Button</a>, for
--   instance with <a>toButton</a>.
class (GObject o, IsDescendantOf Button o) => IsButton o

-- | Emitted when the button is released.
type ButtonReleasedCallback = IO ()

-- | Emitted when the button is pressed.
type ButtonPressedCallback = IO ()

-- | Emitted when the pointer leaves the button.
type ButtonLeaveCallback = IO ()

-- | Emitted when the pointer enters the button.
type ButtonEnterCallback = IO ()

-- | Emitted when the button has been activated (pressed and released).
type ButtonClickedCallback = IO ()

-- | The <a>activate</a> signal on GtkButton is an action signal and
--   emitting it causes the button to animate press then release.
--   Applications should never connect to this signal, but use the
--   <a>Button::clicked</a> signal.
type ButtonActivateCallback = IO ()

-- | Type class for types which can be safely cast to <a>ToggleButton</a>,
--   for instance with <a>toToggleButton</a>.
class (GObject o, IsDescendantOf ToggleButton o) => IsToggleButton o

-- | Memory-managed wrapper type.
newtype () => ToggleButton
ToggleButton :: ManagedPtr ToggleButton -> ToggleButton

-- | Should be connected if you wish to perform an action whenever the
--   <a>ToggleButton</a>'s state is changed.
type ToggleButtonToggledCallback = IO ()

-- | Type class for types which can be safely cast to <a>ScaleButton</a>,
--   for instance with <a>toScaleButton</a>.
class (GObject o, IsDescendantOf ScaleButton o) => IsScaleButton o

-- | The <a>valueChanged</a> signal is emitted when the value field has
--   changed.
--   
--   <i>Since: 2.12</i>
type ScaleButtonValueChangedCallback = Double -> IO ()

-- | The <a>popup</a> signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted to popup the scale widget.
--   
--   The default bindings for this signal are Space, Enter and Return.
--   
--   <i>Since: 2.12</i>
type ScaleButtonPopupCallback = IO ()

-- | The <a>popdown</a> signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted to popdown the scale widget.
--   
--   The default binding for this signal is Escape.
--   
--   <i>Since: 2.12</i>
type ScaleButtonPopdownCallback = IO ()

-- | Type class for types which can be safely cast to <a>VolumeButton</a>,
--   for instance with <a>toVolumeButton</a>.
class (GObject o, IsDescendantOf VolumeButton o) => IsVolumeButton o

-- | Memory-managed wrapper type.
newtype () => VolumeButton
VolumeButton :: ManagedPtr VolumeButton -> VolumeButton

-- | Type class for types which can be safely cast to <a>ModelButton</a>,
--   for instance with <a>toModelButton</a>.
class (GObject o, IsDescendantOf ModelButton o) => IsModelButton o

-- | Type class for types which can be safely cast to <a>MenuButton</a>,
--   for instance with <a>toMenuButton</a>.
class (GObject o, IsDescendantOf MenuButton o) => IsMenuButton o

-- | Memory-managed wrapper type.
newtype () => MenuButton
MenuButton :: ManagedPtr MenuButton -> MenuButton

-- | Type class for types which can be safely cast to <a>LockButton</a>,
--   for instance with <a>toLockButton</a>.
class (GObject o, IsDescendantOf LockButton o) => IsLockButton o

-- | Memory-managed wrapper type.
newtype () => LockButton
LockButton :: ManagedPtr LockButton -> LockButton

-- | Type class for types which can be safely cast to <a>LinkButton</a>,
--   for instance with <a>toLinkButton</a>.
class (GObject o, IsDescendantOf LinkButton o) => IsLinkButton o

-- | Memory-managed wrapper type.
newtype () => LinkButton
LinkButton :: ManagedPtr LinkButton -> LinkButton

-- | The <a>activateLink</a> signal is emitted each time the
--   <a>LinkButton</a> has been clicked.
--   
--   The default handler will call <a>showUriOnWindow</a> with the URI
--   stored inside the <a>LinkButton:uri</a> property.
--   
--   To override the default behavior, you can connect to the
--   <a>activateLink</a> signal and stop the propagation of the signal by
--   returning <a>True</a> from your handler.
type LinkButtonActivateLinkCallback = IO Bool

-- | Type class for types which can be safely cast to <a>InfoBar</a>, for
--   instance with <a>toInfoBar</a>.
class (GObject o, IsDescendantOf InfoBar o) => IsInfoBar o

-- | Memory-managed wrapper type.
newtype () => InfoBar
InfoBar :: ManagedPtr InfoBar -> InfoBar

-- | Emitted when an action widget is clicked or the application programmer
--   calls <a>dialogResponse</a>. The <i><tt>responseId</tt></i> depends on
--   which action widget was clicked.
--   
--   <i>Since: 2.18</i>
type InfoBarResponseCallback = Int32 -> IO ()

-- | The <a>close</a> signal is a [keybinding signal][GtkBindingSignal]
--   which gets emitted when the user uses a keybinding to dismiss the info
--   bar.
--   
--   The default binding for this signal is the Escape key.
--   
--   <i>Since: 2.18</i>
type InfoBarCloseCallback = IO ()

-- | Type class for types which can be safely cast to <a>FontButton</a>,
--   for instance with <a>toFontButton</a>.
class (GObject o, IsDescendantOf FontButton o) => IsFontButton o

-- | Memory-managed wrapper type.
newtype () => FontButton
FontButton :: ManagedPtr FontButton -> FontButton

-- | The <a>fontSet</a> signal is emitted when the user selects a font.
--   When handling this signal, use <a>fontChooserGetFont</a> to find out
--   which font was just selected.
--   
--   Note that this signal is only emitted when the user changes the font.
--   If you need to react to programmatic font changes as well, use the
--   notify<a>font</a> signal.
--   
--   <i>Since: 2.4</i>
type FontButtonFontSetCallback = IO ()

-- | Type class for types which can be safely cast to <a>ColorButton</a>,
--   for instance with <a>toColorButton</a>.
class (GObject o, IsDescendantOf ColorButton o) => IsColorButton o

-- | Memory-managed wrapper type.
newtype () => ColorButton
ColorButton :: ManagedPtr ColorButton -> ColorButton

-- | The <a>colorSet</a> signal is emitted when the user selects a color.
--   When handling this signal, use
--   <tt><i>gtk_color_button_get_rgba()</i></tt> to find out which color
--   was just selected.
--   
--   Note that this signal is only emitted when the user changes the color.
--   If you need to react to programmatic color changes as well, use the
--   notify<a>color</a> signal.
--   
--   <i>Since: 2.4</i>
type ColorButtonColorSetCallback = IO ()

-- | Type class for types which can be safely cast to <a>CheckButton</a>,
--   for instance with <a>toCheckButton</a>.
class (GObject o, IsDescendantOf CheckButton o) => IsCheckButton o

-- | Type class for types which can be safely cast to <a>RadioButton</a>,
--   for instance with <a>toRadioButton</a>.
class (GObject o, IsDescendantOf RadioButton o) => IsRadioButton o

-- | Emitted when the group of radio buttons that a radio button belongs to
--   changes. This is emitted when a radio button switches from being alone
--   to being part of a group of 2 or more buttons, or vice-versa, and when
--   a button is moved from one group of 2 or more buttons to a different
--   one, but not when the composition of the group that a button belongs
--   to changes.
--   
--   <i>Since: 2.4</i>
type RadioButtonGroupChangedCallback = IO ()

-- | Type class for types which can be safely cast to
--   <a>RadioToolButton</a>, for instance with <a>toRadioToolButton</a>.
class (GObject o, IsDescendantOf RadioToolButton o) => IsRadioToolButton o

-- | Memory-managed wrapper type.
newtype () => RadioToolButton
RadioToolButton :: ManagedPtr RadioToolButton -> RadioToolButton

-- | Type class for types which can be safely cast to
--   <a>AppChooserWidget</a>, for instance with <a>toAppChooserWidget</a>.
class (GObject o, IsDescendantOf AppChooserWidget o) => IsAppChooserWidget o

-- | Emitted when a context menu is about to popup over an application
--   item. Clients can insert menu items into the provided <a>Menu</a>
--   object in the callback of this signal; the context menu will be shown
--   over the item if at least one item has been added to the menu.
type AppChooserWidgetPopulatePopupCallback = Menu -> AppInfo -> IO ()

-- | Emitted when an application item is selected from the widget's list.
type AppChooserWidgetApplicationSelectedCallback = AppInfo -> IO ()

-- | Emitted when an application item is activated from the widget's list.
--   
--   This usually happens when the user double clicks an item, or an item
--   is selected and the user presses one of the keys Space, Shift+Space,
--   Return or Enter.
type AppChooserWidgetApplicationActivatedCallback = AppInfo -> IO ()

-- | Type class for types which can be safely cast to <a>AccelLabel</a>,
--   for instance with <a>toAccelLabel</a>.
class (GObject o, IsDescendantOf AccelLabel o) => IsAccelLabel o

-- | Memory-managed wrapper type.
newtype () => WindowGeometryInfo
WindowGeometryInfo :: ManagedPtr WindowGeometryInfo -> WindowGeometryInfo
data () => ActionableActionNamePropertyInfo
data () => ActionableActionTargetPropertyInfo
data () => ActionableGetActionNameMethodInfo
data () => ActionableGetActionTargetValueMethodInfo
data () => ActionableSetActionNameMethodInfo
data () => ActionableSetActionTargetValueMethodInfo
data () => ActionableSetDetailedActionNameMethodInfo
type family ResolveActionableMethod (t :: Symbol) o
data () => ActivatableDoSetRelatedActionMethodInfo
data () => ActivatableGetRelatedActionMethodInfo
data () => ActivatableGetUseActionAppearanceMethodInfo
data () => ActivatableRelatedActionPropertyInfo
data () => ActivatableSetRelatedActionMethodInfo
data () => ActivatableSetUseActionAppearanceMethodInfo
data () => ActivatableSyncActionPropertiesMethodInfo
data () => ActivatableUseActionAppearancePropertyInfo
type family ResolveActivatableMethod (t :: Symbol) o
data () => AppChooserContentTypePropertyInfo
data () => AppChooserGetAppInfoMethodInfo
data () => AppChooserGetContentTypeMethodInfo
data () => AppChooserRefreshMethodInfo
type family ResolveAppChooserMethod (t :: Symbol) o
data () => BuildableAddChildMethodInfo
data () => BuildableConstructChildMethodInfo
data () => BuildableCustomFinishedMethodInfo
data () => BuildableCustomTagEndMethodInfo
data () => BuildableCustomTagStartMethodInfo
data () => BuildableGetInternalChildMethodInfo
data () => BuildableGetNameMethodInfo
data () => BuildableParserFinishedMethodInfo
data () => BuildableSetBuildablePropertyMethodInfo
data () => BuildableSetNameMethodInfo
type family ResolveBuildableMethod (t :: Symbol) o
data () => CellAccessibleParentActivateMethodInfo
data () => CellAccessibleParentEditMethodInfo
data () => CellAccessibleParentExpandCollapseMethodInfo
data () => CellAccessibleParentGetCellAreaMethodInfo
data () => CellAccessibleParentGetCellExtentsMethodInfo
data () => CellAccessibleParentGetCellPositionMethodInfo
data () => CellAccessibleParentGetChildIndexMethodInfo
data () => CellAccessibleParentGetColumnHeaderCellsMethodInfo
data () => CellAccessibleParentGetRendererStateMethodInfo
data () => CellAccessibleParentGetRowHeaderCellsMethodInfo
data () => CellAccessibleParentGrabFocusMethodInfo
data () => CellAccessibleParentUpdateRelationsetMethodInfo
type family ResolveCellAccessibleParentMethod (t :: Symbol) o
data () => CellEditableEditingCanceledPropertyInfo
data () => CellEditableEditingDoneMethodInfo
data () => CellEditableEditingDoneSignalInfo
data () => CellEditableRemoveWidgetMethodInfo
data () => CellEditableRemoveWidgetSignalInfo
data () => CellEditableStartEditingMethodInfo
type family ResolveCellEditableMethod (t :: Symbol) o
data () => CellLayoutAddAttributeMethodInfo
data () => CellLayoutClearAttributesMethodInfo
data () => CellLayoutClearMethodInfo
data () => CellLayoutGetAreaMethodInfo
data () => CellLayoutGetCellsMethodInfo
data () => CellLayoutPackEndMethodInfo
data () => CellLayoutPackStartMethodInfo
data () => CellLayoutReorderMethodInfo
data () => CellLayoutSetCellDataFuncMethodInfo
type family ResolveCellLayoutMethod (t :: Symbol) o
data () => ColorChooserAddPaletteMethodInfo
data () => ColorChooserColorActivatedSignalInfo
data () => ColorChooserGetRgbaMethodInfo
data () => ColorChooserGetUseAlphaMethodInfo
data () => ColorChooserRgbaPropertyInfo
data () => ColorChooserSetRgbaMethodInfo
data () => ColorChooserSetUseAlphaMethodInfo
data () => ColorChooserUseAlphaPropertyInfo
type family ResolveColorChooserMethod (t :: Symbol) o
data () => EditableChangedSignalInfo
data () => EditableCopyClipboardMethodInfo
data () => EditableCutClipboardMethodInfo
data () => EditableDeleteSelectionMethodInfo
data () => EditableDeleteTextMethodInfo
data () => EditableDeleteTextSignalInfo
data () => EditableGetCharsMethodInfo
data () => EditableGetEditableMethodInfo
data () => EditableGetPositionMethodInfo
data () => EditableGetSelectionBoundsMethodInfo
data () => EditableInsertTextMethodInfo
data () => EditableInsertTextSignalInfo
data () => EditablePasteClipboardMethodInfo
data () => EditableSelectRegionMethodInfo
data () => EditableSetEditableMethodInfo
data () => EditableSetPositionMethodInfo
type family ResolveEditableMethod (t :: Symbol) o
data () => FileChooserActionPropertyInfo
data () => FileChooserAddChoiceMethodInfo
data () => FileChooserAddFilterMethodInfo
data () => FileChooserAddShortcutFolderMethodInfo
data () => FileChooserAddShortcutFolderUriMethodInfo
data () => FileChooserConfirmOverwriteSignalInfo
data () => FileChooserCreateFoldersPropertyInfo
data () => FileChooserCurrentFolderChangedSignalInfo
data () => FileChooserDoOverwriteConfirmationPropertyInfo
data () => FileChooserExtraWidgetPropertyInfo
data () => FileChooserFileActivatedSignalInfo
data () => FileChooserFilterPropertyInfo
data () => FileChooserGetActionMethodInfo
data () => FileChooserGetChoiceMethodInfo
data () => FileChooserGetCreateFoldersMethodInfo
data () => FileChooserGetCurrentFolderFileMethodInfo
data () => FileChooserGetCurrentFolderMethodInfo
data () => FileChooserGetCurrentFolderUriMethodInfo
data () => FileChooserGetCurrentNameMethodInfo
data () => FileChooserGetDoOverwriteConfirmationMethodInfo
data () => FileChooserGetExtraWidgetMethodInfo
data () => FileChooserGetFileMethodInfo
data () => FileChooserGetFilenameMethodInfo
data () => FileChooserGetFilenamesMethodInfo
data () => FileChooserGetFilesMethodInfo
data () => FileChooserGetFilterMethodInfo
data () => FileChooserGetLocalOnlyMethodInfo
data () => FileChooserGetPreviewFileMethodInfo
data () => FileChooserGetPreviewFilenameMethodInfo
data () => FileChooserGetPreviewUriMethodInfo
data () => FileChooserGetPreviewWidgetActiveMethodInfo
data () => FileChooserGetPreviewWidgetMethodInfo
data () => FileChooserGetSelectMultipleMethodInfo
data () => FileChooserGetShowHiddenMethodInfo
data () => FileChooserGetUriMethodInfo
data () => FileChooserGetUrisMethodInfo
data () => FileChooserGetUsePreviewLabelMethodInfo
data () => FileChooserListFiltersMethodInfo
data () => FileChooserListShortcutFolderUrisMethodInfo
data () => FileChooserListShortcutFoldersMethodInfo
data () => FileChooserLocalOnlyPropertyInfo
data () => FileChooserPreviewWidgetActivePropertyInfo
data () => FileChooserPreviewWidgetPropertyInfo
data () => FileChooserRemoveChoiceMethodInfo
data () => FileChooserRemoveFilterMethodInfo
data () => FileChooserRemoveShortcutFolderMethodInfo
data () => FileChooserRemoveShortcutFolderUriMethodInfo
data () => FileChooserSelectAllMethodInfo
data () => FileChooserSelectFileMethodInfo
data () => FileChooserSelectFilenameMethodInfo
data () => FileChooserSelectMultiplePropertyInfo
data () => FileChooserSelectUriMethodInfo
data () => FileChooserSelectionChangedSignalInfo
data () => FileChooserSetActionMethodInfo
data () => FileChooserSetChoiceMethodInfo
data () => FileChooserSetCreateFoldersMethodInfo
data () => FileChooserSetCurrentFolderFileMethodInfo
data () => FileChooserSetCurrentFolderMethodInfo
data () => FileChooserSetCurrentFolderUriMethodInfo
data () => FileChooserSetCurrentNameMethodInfo
data () => FileChooserSetDoOverwriteConfirmationMethodInfo
data () => FileChooserSetExtraWidgetMethodInfo
data () => FileChooserSetFileMethodInfo
data () => FileChooserSetFilenameMethodInfo
data () => FileChooserSetFilterMethodInfo
data () => FileChooserSetLocalOnlyMethodInfo
data () => FileChooserSetPreviewWidgetActiveMethodInfo
data () => FileChooserSetPreviewWidgetMethodInfo
data () => FileChooserSetSelectMultipleMethodInfo
data () => FileChooserSetShowHiddenMethodInfo
data () => FileChooserSetUriMethodInfo
data () => FileChooserSetUsePreviewLabelMethodInfo
data () => FileChooserShowHiddenPropertyInfo
data () => FileChooserUnselectAllMethodInfo
data () => FileChooserUnselectFileMethodInfo
data () => FileChooserUnselectFilenameMethodInfo
data () => FileChooserUnselectUriMethodInfo
data () => FileChooserUpdatePreviewSignalInfo
data () => FileChooserUsePreviewLabelPropertyInfo
type family ResolveFileChooserMethod (t :: Symbol) o
data () => FontChooserFontActivatedSignalInfo
data () => FontChooserFontDescPropertyInfo
data () => FontChooserFontFeaturesPropertyInfo
data () => FontChooserFontPropertyInfo
data () => FontChooserGetFontDescMethodInfo
data () => FontChooserGetFontFaceMethodInfo
data () => FontChooserGetFontFamilyMethodInfo
data () => FontChooserGetFontFeaturesMethodInfo
data () => FontChooserGetFontMapMethodInfo
data () => FontChooserGetFontMethodInfo
data () => FontChooserGetFontSizeMethodInfo
data () => FontChooserGetLanguageMethodInfo
data () => FontChooserGetLevelMethodInfo
data () => FontChooserGetPreviewTextMethodInfo
data () => FontChooserGetShowPreviewEntryMethodInfo
data () => FontChooserLanguagePropertyInfo
data () => FontChooserLevelPropertyInfo
data () => FontChooserPreviewTextPropertyInfo
data () => FontChooserSetFilterFuncMethodInfo
data () => FontChooserSetFontDescMethodInfo
data () => FontChooserSetFontMapMethodInfo
data () => FontChooserSetFontMethodInfo
data () => FontChooserSetLanguageMethodInfo
data () => FontChooserSetLevelMethodInfo
data () => FontChooserSetPreviewTextMethodInfo
data () => FontChooserSetShowPreviewEntryMethodInfo
data () => FontChooserShowPreviewEntryPropertyInfo
type family ResolveFontChooserMethod (t :: Symbol) o
data () => OrientableGetOrientationMethodInfo
data () => OrientableOrientationPropertyInfo
data () => OrientableSetOrientationMethodInfo
type family ResolveOrientableMethod (t :: Symbol) o
data () => PrintOperationPreviewEndPreviewMethodInfo
data () => PrintOperationPreviewGotPageSizeSignalInfo
data () => PrintOperationPreviewIsSelectedMethodInfo
data () => PrintOperationPreviewReadySignalInfo
data () => PrintOperationPreviewRenderPageMethodInfo
type family ResolvePrintOperationPreviewMethod (t :: Symbol) o
data () => RecentChooserAddFilterMethodInfo
data () => RecentChooserFilterPropertyInfo
data () => RecentChooserGetCurrentItemMethodInfo
data () => RecentChooserGetCurrentUriMethodInfo
data () => RecentChooserGetFilterMethodInfo
data () => RecentChooserGetItemsMethodInfo
data () => RecentChooserGetLimitMethodInfo
data () => RecentChooserGetLocalOnlyMethodInfo
data () => RecentChooserGetSelectMultipleMethodInfo
data () => RecentChooserGetShowIconsMethodInfo
data () => RecentChooserGetShowNotFoundMethodInfo
data () => RecentChooserGetShowPrivateMethodInfo
data () => RecentChooserGetShowTipsMethodInfo
data () => RecentChooserGetSortTypeMethodInfo
data () => RecentChooserGetUrisMethodInfo
data () => RecentChooserItemActivatedSignalInfo
data () => RecentChooserLimitPropertyInfo
data () => RecentChooserListFiltersMethodInfo
data () => RecentChooserLocalOnlyPropertyInfo
data () => RecentChooserRecentManagerPropertyInfo
data () => RecentChooserRemoveFilterMethodInfo
data () => RecentChooserSelectAllMethodInfo
data () => RecentChooserSelectMultiplePropertyInfo
data () => RecentChooserSelectUriMethodInfo
data () => RecentChooserSelectionChangedSignalInfo
data () => RecentChooserSetCurrentUriMethodInfo
data () => RecentChooserSetFilterMethodInfo
data () => RecentChooserSetLimitMethodInfo
data () => RecentChooserSetLocalOnlyMethodInfo
data () => RecentChooserSetSelectMultipleMethodInfo
data () => RecentChooserSetShowIconsMethodInfo
data () => RecentChooserSetShowNotFoundMethodInfo
data () => RecentChooserSetShowPrivateMethodInfo
data () => RecentChooserSetShowTipsMethodInfo
data () => RecentChooserSetSortFuncMethodInfo
data () => RecentChooserSetSortTypeMethodInfo
data () => RecentChooserShowIconsPropertyInfo
data () => RecentChooserShowNotFoundPropertyInfo
data () => RecentChooserShowPrivatePropertyInfo
data () => RecentChooserShowTipsPropertyInfo
data () => RecentChooserSortTypePropertyInfo
data () => RecentChooserUnselectAllMethodInfo
data () => RecentChooserUnselectUriMethodInfo
type family ResolveRecentChooserMethod (t :: Symbol) o
type family ResolveScrollableMethod (t :: Symbol) o
data () => ScrollableGetBorderMethodInfo
data () => ScrollableGetHadjustmentMethodInfo
data () => ScrollableGetHscrollPolicyMethodInfo
data () => ScrollableGetVadjustmentMethodInfo
data () => ScrollableGetVscrollPolicyMethodInfo
data () => ScrollableHadjustmentPropertyInfo
data () => ScrollableHscrollPolicyPropertyInfo
data () => ScrollableSetHadjustmentMethodInfo
data () => ScrollableSetHscrollPolicyMethodInfo
data () => ScrollableSetVadjustmentMethodInfo
data () => ScrollableSetVscrollPolicyMethodInfo
data () => ScrollableVadjustmentPropertyInfo
data () => ScrollableVscrollPolicyPropertyInfo
type family ResolveStyleProviderMethod (t :: Symbol) o
data () => StyleProviderGetIconFactoryMethodInfo
data () => StyleProviderGetStyleMethodInfo
data () => StyleProviderGetStylePropertyMethodInfo
type family ResolveToolShellMethod (t :: Symbol) o
data () => ToolShellGetEllipsizeModeMethodInfo
data () => ToolShellGetIconSizeMethodInfo
data () => ToolShellGetOrientationMethodInfo
data () => ToolShellGetReliefStyleMethodInfo
data () => ToolShellGetStyleMethodInfo
data () => ToolShellGetTextAlignmentMethodInfo
data () => ToolShellGetTextOrientationMethodInfo
data () => ToolShellGetTextSizeGroupMethodInfo
data () => ToolShellRebuildMenuMethodInfo
type family ResolveTreeDragDestMethod (t :: Symbol) o
data () => TreeDragDestDragDataReceivedMethodInfo
data () => TreeDragDestRowDropPossibleMethodInfo
type family ResolveTreeDragSourceMethod (t :: Symbol) o
data () => TreeDragSourceDragDataDeleteMethodInfo
data () => TreeDragSourceDragDataGetMethodInfo
data () => TreeDragSourceRowDraggableMethodInfo
type family ResolveTreeModelMethod (t :: Symbol) o
data () => TreeModelFilterNewMethodInfo
data () => TreeModelForeachMethodInfo
data () => TreeModelGetColumnTypeMethodInfo
data () => TreeModelGetFlagsMethodInfo
data () => TreeModelGetIterFirstMethodInfo
data () => TreeModelGetIterFromStringMethodInfo
data () => TreeModelGetIterMethodInfo
data () => TreeModelGetNColumnsMethodInfo
data () => TreeModelGetPathMethodInfo
data () => TreeModelGetStringFromIterMethodInfo
data () => TreeModelGetValueMethodInfo
data () => TreeModelIterChildrenMethodInfo
data () => TreeModelIterHasChildMethodInfo
data () => TreeModelIterNChildrenMethodInfo
data () => TreeModelIterNextMethodInfo
data () => TreeModelIterNthChildMethodInfo
data () => TreeModelIterParentMethodInfo
data () => TreeModelIterPreviousMethodInfo
data () => TreeModelRefNodeMethodInfo
data () => TreeModelRowChangedMethodInfo
data () => TreeModelRowChangedSignalInfo
data () => TreeModelRowDeletedMethodInfo
data () => TreeModelRowDeletedSignalInfo
data () => TreeModelRowHasChildToggledMethodInfo
data () => TreeModelRowHasChildToggledSignalInfo
data () => TreeModelRowInsertedMethodInfo
data () => TreeModelRowInsertedSignalInfo
data () => TreeModelRowsReorderedMethodInfo
data () => TreeModelUnrefNodeMethodInfo
type family ResolveTreeSortableMethod (t :: Symbol) o
data () => TreeSortableGetSortColumnIdMethodInfo
data () => TreeSortableHasDefaultSortFuncMethodInfo
data () => TreeSortableSetDefaultSortFuncMethodInfo
data () => TreeSortableSetSortColumnIdMethodInfo
data () => TreeSortableSetSortFuncMethodInfo
data () => TreeSortableSortColumnChangedMethodInfo
data () => TreeSortableSortColumnChangedSignalInfo
data () => AboutDialogActivateLinkSignalInfo
data () => AboutDialogAddCreditSectionMethodInfo
data () => AboutDialogArtistsPropertyInfo
data () => AboutDialogAuthorsPropertyInfo
data () => AboutDialogCommentsPropertyInfo
data () => AboutDialogCopyrightPropertyInfo
data () => AboutDialogDocumentersPropertyInfo
data () => AboutDialogGetArtistsMethodInfo
data () => AboutDialogGetAuthorsMethodInfo
data () => AboutDialogGetCommentsMethodInfo
data () => AboutDialogGetCopyrightMethodInfo
data () => AboutDialogGetDocumentersMethodInfo
data () => AboutDialogGetLicenseMethodInfo
data () => AboutDialogGetLicenseTypeMethodInfo
data () => AboutDialogGetLogoIconNameMethodInfo
data () => AboutDialogGetLogoMethodInfo
data () => AboutDialogGetProgramNameMethodInfo
data () => AboutDialogGetTranslatorCreditsMethodInfo
data () => AboutDialogGetVersionMethodInfo
data () => AboutDialogGetWebsiteLabelMethodInfo
data () => AboutDialogGetWebsiteMethodInfo
data () => AboutDialogGetWrapLicenseMethodInfo
data () => AboutDialogLicensePropertyInfo
data () => AboutDialogLicenseTypePropertyInfo
data () => AboutDialogLogoIconNamePropertyInfo
data () => AboutDialogLogoPropertyInfo
data () => AboutDialogProgramNamePropertyInfo
data () => AboutDialogSetArtistsMethodInfo
data () => AboutDialogSetAuthorsMethodInfo
data () => AboutDialogSetCommentsMethodInfo
data () => AboutDialogSetCopyrightMethodInfo
data () => AboutDialogSetDocumentersMethodInfo
data () => AboutDialogSetLicenseMethodInfo
data () => AboutDialogSetLicenseTypeMethodInfo
data () => AboutDialogSetLogoIconNameMethodInfo
data () => AboutDialogSetLogoMethodInfo
data () => AboutDialogSetProgramNameMethodInfo
data () => AboutDialogSetTranslatorCreditsMethodInfo
data () => AboutDialogSetVersionMethodInfo
data () => AboutDialogSetWebsiteLabelMethodInfo
data () => AboutDialogSetWebsiteMethodInfo
data () => AboutDialogSetWrapLicenseMethodInfo
data () => AboutDialogTranslatorCreditsPropertyInfo
data () => AboutDialogVersionPropertyInfo
data () => AboutDialogWebsiteLabelPropertyInfo
data () => AboutDialogWebsitePropertyInfo
data () => AboutDialogWrapLicensePropertyInfo
type family ResolveAboutDialogMethod (t :: Symbol) o
data () => AccelGroupAccelActivateSignalInfo
data () => AccelGroupAccelChangedSignalInfo
data () => AccelGroupActivateMethodInfo
data () => AccelGroupConnectByPathMethodInfo
data () => AccelGroupConnectMethodInfo
data () => AccelGroupDisconnectKeyMethodInfo
data () => AccelGroupDisconnectMethodInfo
data () => AccelGroupFindMethodInfo
data () => AccelGroupGetIsLockedMethodInfo
data () => AccelGroupGetModifierMaskMethodInfo
data () => AccelGroupIsLockedPropertyInfo
data () => AccelGroupLockMethodInfo
data () => AccelGroupModifierMaskPropertyInfo
data () => AccelGroupQueryMethodInfo
data () => AccelGroupUnlockMethodInfo
type family ResolveAccelGroupMethod (t :: Symbol) o
data () => AccelLabelAccelClosurePropertyInfo
data () => AccelLabelAccelWidgetPropertyInfo
data () => AccelLabelGetAccelMethodInfo
data () => AccelLabelGetAccelWidgetMethodInfo
data () => AccelLabelGetAccelWidthMethodInfo
data () => AccelLabelRefetchMethodInfo
data () => AccelLabelSetAccelClosureMethodInfo
data () => AccelLabelSetAccelMethodInfo
data () => AccelLabelSetAccelWidgetMethodInfo
type family ResolveAccelLabelMethod (t :: Symbol) o
data () => AccelMapChangedSignalInfo
type family ResolveAccelMapMethod (t :: Symbol) o
data () => AccessibleConnectWidgetDestroyedMethodInfo
data () => AccessibleGetWidgetMethodInfo
data () => AccessibleSetWidgetMethodInfo
data () => AccessibleWidgetPropertyInfo
type family ResolveAccessibleMethod (t :: Symbol) o
data () => ActionActionGroupPropertyInfo
data () => ActionActivateMethodInfo
data () => ActionActivateSignalInfo
data () => ActionAlwaysShowImagePropertyInfo
data () => ActionBlockActivateMethodInfo
data () => ActionConnectAcceleratorMethodInfo
data () => ActionCreateIconMethodInfo
data () => ActionCreateMenuItemMethodInfo
data () => ActionCreateMenuMethodInfo
data () => ActionCreateToolItemMethodInfo
data () => ActionDisconnectAcceleratorMethodInfo
data () => ActionGetAccelClosureMethodInfo
data () => ActionGetAccelPathMethodInfo
data () => ActionGetAlwaysShowImageMethodInfo
data () => ActionGetGiconMethodInfo
data () => ActionGetIconNameMethodInfo
data () => ActionGetIsImportantMethodInfo
data () => ActionGetLabelMethodInfo
data () => ActionGetNameMethodInfo
data () => ActionGetProxiesMethodInfo
data () => ActionGetSensitiveMethodInfo
data () => ActionGetShortLabelMethodInfo
data () => ActionGetStockIdMethodInfo
data () => ActionGetTooltipMethodInfo
data () => ActionGetVisibleHorizontalMethodInfo
data () => ActionGetVisibleMethodInfo
data () => ActionGetVisibleVerticalMethodInfo
data () => ActionGiconPropertyInfo
data () => ActionHideIfEmptyPropertyInfo
data () => ActionIconNamePropertyInfo
data () => ActionIsImportantPropertyInfo
data () => ActionIsSensitiveMethodInfo
data () => ActionIsVisibleMethodInfo
data () => ActionLabelPropertyInfo
data () => ActionNamePropertyInfo
data () => ActionSensitivePropertyInfo
data () => ActionSetAccelGroupMethodInfo
data () => ActionSetAccelPathMethodInfo
data () => ActionSetAlwaysShowImageMethodInfo
data () => ActionSetGiconMethodInfo
data () => ActionSetIconNameMethodInfo
data () => ActionSetIsImportantMethodInfo
data () => ActionSetLabelMethodInfo
data () => ActionSetSensitiveMethodInfo
data () => ActionSetShortLabelMethodInfo
data () => ActionSetStockIdMethodInfo
data () => ActionSetTooltipMethodInfo
data () => ActionSetVisibleHorizontalMethodInfo
data () => ActionSetVisibleMethodInfo
data () => ActionSetVisibleVerticalMethodInfo
data () => ActionShortLabelPropertyInfo
data () => ActionStockIdPropertyInfo
data () => ActionTooltipPropertyInfo
data () => ActionUnblockActivateMethodInfo
data () => ActionVisibleHorizontalPropertyInfo
data () => ActionVisibleOverflownPropertyInfo
data () => ActionVisiblePropertyInfo
data () => ActionVisibleVerticalPropertyInfo
type family ResolveActionMethod (t :: Symbol) o
data () => ActionBarGetCenterWidgetMethodInfo
data () => ActionBarPackEndMethodInfo
data () => ActionBarPackStartMethodInfo
data () => ActionBarSetCenterWidgetMethodInfo
type family ResolveActionBarMethod (t :: Symbol) o
data () => ActionGroupAccelGroupPropertyInfo
data () => ActionGroupAddActionMethodInfo
data () => ActionGroupAddActionWithAccelMethodInfo
data () => ActionGroupConnectProxySignalInfo
data () => ActionGroupDisconnectProxySignalInfo
data () => ActionGroupGetAccelGroupMethodInfo
data () => ActionGroupGetActionMethodInfo
data () => ActionGroupGetNameMethodInfo
data () => ActionGroupGetSensitiveMethodInfo
data () => ActionGroupGetVisibleMethodInfo
data () => ActionGroupListActionsMethodInfo
data () => ActionGroupNamePropertyInfo
data () => ActionGroupPostActivateSignalInfo
data () => ActionGroupPreActivateSignalInfo
data () => ActionGroupRemoveActionMethodInfo
data () => ActionGroupSensitivePropertyInfo
data () => ActionGroupSetAccelGroupMethodInfo
data () => ActionGroupSetSensitiveMethodInfo
data () => ActionGroupSetTranslateFuncMethodInfo
data () => ActionGroupSetTranslationDomainMethodInfo
data () => ActionGroupSetVisibleMethodInfo
data () => ActionGroupTranslateStringMethodInfo
data () => ActionGroupVisiblePropertyInfo
type family ResolveActionGroupMethod (t :: Symbol) o
data () => AdjustmentChangedMethodInfo
data () => AdjustmentChangedSignalInfo
data () => AdjustmentClampPageMethodInfo
data () => AdjustmentConfigureMethodInfo
data () => AdjustmentGetLowerMethodInfo
data () => AdjustmentGetMinimumIncrementMethodInfo
data () => AdjustmentGetPageIncrementMethodInfo
data () => AdjustmentGetPageSizeMethodInfo
data () => AdjustmentGetStepIncrementMethodInfo
data () => AdjustmentGetUpperMethodInfo
data () => AdjustmentGetValueMethodInfo
data () => AdjustmentLowerPropertyInfo
data () => AdjustmentPageIncrementPropertyInfo
data () => AdjustmentPageSizePropertyInfo
data () => AdjustmentSetLowerMethodInfo
data () => AdjustmentSetPageIncrementMethodInfo
data () => AdjustmentSetPageSizeMethodInfo
data () => AdjustmentSetStepIncrementMethodInfo
data () => AdjustmentSetUpperMethodInfo
data () => AdjustmentSetValueMethodInfo
data () => AdjustmentStepIncrementPropertyInfo
data () => AdjustmentUpperPropertyInfo
data () => AdjustmentValueChangedMethodInfo
data () => AdjustmentValueChangedSignalInfo
data () => AdjustmentValuePropertyInfo
type family ResolveAdjustmentMethod (t :: Symbol) o
data () => AlignmentBottomPaddingPropertyInfo
data () => AlignmentGetPaddingMethodInfo
data () => AlignmentLeftPaddingPropertyInfo
data () => AlignmentRightPaddingPropertyInfo
data () => AlignmentSetMethodInfo
data () => AlignmentSetPaddingMethodInfo
data () => AlignmentTopPaddingPropertyInfo
data () => AlignmentXalignPropertyInfo
data () => AlignmentXscalePropertyInfo
data () => AlignmentYalignPropertyInfo
data () => AlignmentYscalePropertyInfo
type family ResolveAlignmentMethod (t :: Symbol) o
data () => AppChooserButtonAppendCustomItemMethodInfo
data () => AppChooserButtonAppendSeparatorMethodInfo
data () => AppChooserButtonCustomItemActivatedSignalInfo
data () => AppChooserButtonGetHeadingMethodInfo
data () => AppChooserButtonGetShowDefaultItemMethodInfo
data () => AppChooserButtonGetShowDialogItemMethodInfo
data () => AppChooserButtonHeadingPropertyInfo
data () => AppChooserButtonSetActiveCustomItemMethodInfo
data () => AppChooserButtonSetHeadingMethodInfo
data () => AppChooserButtonSetShowDefaultItemMethodInfo
data () => AppChooserButtonSetShowDialogItemMethodInfo
data () => AppChooserButtonShowDefaultItemPropertyInfo
data () => AppChooserButtonShowDialogItemPropertyInfo
type family ResolveAppChooserButtonMethod (t :: Symbol) o
data () => AppChooserDialogGetHeadingMethodInfo
data () => AppChooserDialogGetWidgetMethodInfo
data () => AppChooserDialogGfilePropertyInfo
data () => AppChooserDialogHeadingPropertyInfo
data () => AppChooserDialogSetHeadingMethodInfo
type family ResolveAppChooserDialogMethod (t :: Symbol) o
data () => AppChooserWidgetApplicationActivatedSignalInfo
data () => AppChooserWidgetApplicationSelectedSignalInfo
data () => AppChooserWidgetDefaultTextPropertyInfo
data () => AppChooserWidgetGetDefaultTextMethodInfo
data () => AppChooserWidgetGetShowAllMethodInfo
data () => AppChooserWidgetGetShowDefaultMethodInfo
data () => AppChooserWidgetGetShowFallbackMethodInfo
data () => AppChooserWidgetGetShowOtherMethodInfo
data () => AppChooserWidgetGetShowRecommendedMethodInfo
data () => AppChooserWidgetPopulatePopupSignalInfo
data () => AppChooserWidgetSetDefaultTextMethodInfo
data () => AppChooserWidgetSetShowAllMethodInfo
data () => AppChooserWidgetSetShowDefaultMethodInfo
data () => AppChooserWidgetSetShowFallbackMethodInfo
data () => AppChooserWidgetSetShowOtherMethodInfo
data () => AppChooserWidgetSetShowRecommendedMethodInfo
data () => AppChooserWidgetShowAllPropertyInfo
data () => AppChooserWidgetShowDefaultPropertyInfo
data () => AppChooserWidgetShowFallbackPropertyInfo
data () => AppChooserWidgetShowOtherPropertyInfo
data () => AppChooserWidgetShowRecommendedPropertyInfo
type family ResolveAppChooserWidgetMethod (t :: Symbol) o
data () => ApplicationActiveWindowPropertyInfo
data () => ApplicationAddAcceleratorMethodInfo
data () => ApplicationAddWindowMethodInfo
data () => ApplicationAppMenuPropertyInfo
data () => ApplicationGetAccelsForActionMethodInfo
data () => ApplicationGetActionsForAccelMethodInfo
data () => ApplicationGetActiveWindowMethodInfo
data () => ApplicationGetAppMenuMethodInfo
data () => ApplicationGetMenuByIdMethodInfo
data () => ApplicationGetMenubarMethodInfo
data () => ApplicationGetWindowByIdMethodInfo
data () => ApplicationGetWindowsMethodInfo
data () => ApplicationInhibitMethodInfo
data () => ApplicationIsInhibitedMethodInfo
data () => ApplicationListActionDescriptionsMethodInfo
data () => ApplicationMenubarPropertyInfo
data () => ApplicationPrefersAppMenuMethodInfo
data () => ApplicationQueryEndSignalInfo
data () => ApplicationRegisterSessionPropertyInfo
data () => ApplicationRemoveAcceleratorMethodInfo
data () => ApplicationRemoveWindowMethodInfo
data () => ApplicationScreensaverActivePropertyInfo
data () => ApplicationSetAccelsForActionMethodInfo
data () => ApplicationSetAppMenuMethodInfo
data () => ApplicationSetMenubarMethodInfo
data () => ApplicationUninhibitMethodInfo
data () => ApplicationWindowAddedSignalInfo
data () => ApplicationWindowRemovedSignalInfo
type family ResolveApplicationMethod (t :: Symbol) o
data () => ApplicationWindowGetHelpOverlayMethodInfo
data () => ApplicationWindowGetIdMethodInfo
data () => ApplicationWindowGetShowMenubarMethodInfo
data () => ApplicationWindowSetHelpOverlayMethodInfo
data () => ApplicationWindowSetShowMenubarMethodInfo
data () => ApplicationWindowShowMenubarPropertyInfo
type family ResolveApplicationWindowMethod (t :: Symbol) o
data () => ArrowArrowTypePropertyInfo
data () => ArrowSetMethodInfo
data () => ArrowShadowTypePropertyInfo
type family ResolveArrowMethod (t :: Symbol) o
type family ResolveArrowAccessibleMethod (t :: Symbol) o
data () => AspectFrameObeyChildPropertyInfo
data () => AspectFrameRatioPropertyInfo
data () => AspectFrameSetMethodInfo
data () => AspectFrameXalignPropertyInfo
data () => AspectFrameYalignPropertyInfo
type family ResolveAspectFrameMethod (t :: Symbol) o
data () => AssistantAddActionWidgetMethodInfo
data () => AssistantAppendPageMethodInfo
data () => AssistantApplySignalInfo
data () => AssistantCancelSignalInfo
data () => AssistantCloseSignalInfo
data () => AssistantCommitMethodInfo
data () => AssistantEscapeSignalInfo
data () => AssistantGetCurrentPageMethodInfo
data () => AssistantGetNPagesMethodInfo
data () => AssistantGetNthPageMethodInfo
data () => AssistantGetPageCompleteMethodInfo
data () => AssistantGetPageHasPaddingMethodInfo
data () => AssistantGetPageHeaderImageMethodInfo
data () => AssistantGetPageSideImageMethodInfo
data () => AssistantGetPageTitleMethodInfo
data () => AssistantGetPageTypeMethodInfo
data () => AssistantInsertPageMethodInfo
data () => AssistantNextPageMethodInfo
data () => AssistantPrepareSignalInfo
data () => AssistantPrependPageMethodInfo
data () => AssistantPreviousPageMethodInfo
data () => AssistantRemoveActionWidgetMethodInfo
data () => AssistantRemovePageMethodInfo
data () => AssistantSetCurrentPageMethodInfo
data () => AssistantSetForwardPageFuncMethodInfo
data () => AssistantSetPageCompleteMethodInfo
data () => AssistantSetPageHasPaddingMethodInfo
data () => AssistantSetPageHeaderImageMethodInfo
data () => AssistantSetPageSideImageMethodInfo
data () => AssistantSetPageTitleMethodInfo
data () => AssistantSetPageTypeMethodInfo
data () => AssistantUpdateButtonsStateMethodInfo
data () => AssistantUseHeaderBarPropertyInfo
type family ResolveAssistantMethod (t :: Symbol) o
data () => BinGetChildMethodInfo
type family ResolveBinMethod (t :: Symbol) o
type family ResolveBooleanCellAccessibleMethod (t :: Symbol) o
data () => BoxBaselinePositionPropertyInfo
data () => BoxGetBaselinePositionMethodInfo
data () => BoxGetCenterWidgetMethodInfo
data () => BoxGetHomogeneousMethodInfo
data () => BoxGetSpacingMethodInfo
data () => BoxHomogeneousPropertyInfo
data () => BoxPackEndMethodInfo
data () => BoxPackStartMethodInfo
data () => BoxQueryChildPackingMethodInfo
data () => BoxReorderChildMethodInfo
data () => BoxSetBaselinePositionMethodInfo
data () => BoxSetCenterWidgetMethodInfo
data () => BoxSetChildPackingMethodInfo
data () => BoxSetHomogeneousMethodInfo
data () => BoxSetSpacingMethodInfo
data () => BoxSpacingPropertyInfo
type family ResolveBoxMethod (t :: Symbol) o
data () => BuilderAddCallbackSymbolMethodInfo
data () => BuilderAddFromFileMethodInfo
data () => BuilderAddFromResourceMethodInfo
data () => BuilderAddFromStringMethodInfo
data () => BuilderAddObjectsFromFileMethodInfo
data () => BuilderAddObjectsFromResourceMethodInfo
data () => BuilderAddObjectsFromStringMethodInfo
data () => BuilderConnectSignalsFullMethodInfo
data () => BuilderConnectSignalsMethodInfo
data () => BuilderExposeObjectMethodInfo
data () => BuilderExtendWithTemplateMethodInfo
data () => BuilderGetApplicationMethodInfo
data () => BuilderGetObjectMethodInfo
data () => BuilderGetObjectsMethodInfo
data () => BuilderGetTranslationDomainMethodInfo
data () => BuilderGetTypeFromNameMethodInfo
data () => BuilderSetApplicationMethodInfo
data () => BuilderSetTranslationDomainMethodInfo
data () => BuilderTranslationDomainPropertyInfo
data () => BuilderValueFromStringMethodInfo
data () => BuilderValueFromStringTypeMethodInfo
type family ResolveBuilderMethod (t :: Symbol) o
data () => ButtonActivateSignalInfo
data () => ButtonAlwaysShowImagePropertyInfo
data () => ButtonClickedMethodInfo
data () => ButtonClickedSignalInfo
data () => ButtonEnterMethodInfo
data () => ButtonEnterSignalInfo
data () => ButtonGetAlignmentMethodInfo
data () => ButtonGetAlwaysShowImageMethodInfo
data () => ButtonGetEventWindowMethodInfo
data () => ButtonGetFocusOnClickMethodInfo
data () => ButtonGetImageMethodInfo
data () => ButtonGetImagePositionMethodInfo
data () => ButtonGetLabelMethodInfo
data () => ButtonGetReliefMethodInfo
data () => ButtonGetUseStockMethodInfo
data () => ButtonGetUseUnderlineMethodInfo
data () => ButtonImagePositionPropertyInfo
data () => ButtonImagePropertyInfo
data () => ButtonLabelPropertyInfo
data () => ButtonLeaveMethodInfo
data () => ButtonLeaveSignalInfo
data () => ButtonPressedMethodInfo
data () => ButtonPressedSignalInfo
data () => ButtonReleasedMethodInfo
data () => ButtonReleasedSignalInfo
data () => ButtonReliefPropertyInfo
data () => ButtonSetAlignmentMethodInfo
data () => ButtonSetAlwaysShowImageMethodInfo
data () => ButtonSetFocusOnClickMethodInfo
data () => ButtonSetImageMethodInfo
data () => ButtonSetImagePositionMethodInfo
data () => ButtonSetLabelMethodInfo
data () => ButtonSetReliefMethodInfo
data () => ButtonSetUseStockMethodInfo
data () => ButtonSetUseUnderlineMethodInfo
data () => ButtonUseStockPropertyInfo
data () => ButtonUseUnderlinePropertyInfo
data () => ButtonXalignPropertyInfo
data () => ButtonYalignPropertyInfo
type family ResolveButtonMethod (t :: Symbol) o
type family ResolveButtonAccessibleMethod (t :: Symbol) o
data () => ButtonBoxGetChildNonHomogeneousMethodInfo
data () => ButtonBoxGetChildSecondaryMethodInfo
data () => ButtonBoxGetLayoutMethodInfo
data () => ButtonBoxLayoutStylePropertyInfo
data () => ButtonBoxSetChildNonHomogeneousMethodInfo
data () => ButtonBoxSetChildSecondaryMethodInfo
data () => ButtonBoxSetLayoutMethodInfo
type family ResolveButtonBoxMethod (t :: Symbol) o
data () => CalendarClearMarksMethodInfo
data () => CalendarDayPropertyInfo
data () => CalendarDaySelectedDoubleClickSignalInfo
data () => CalendarDaySelectedSignalInfo
data () => CalendarDetailHeightRowsPropertyInfo
data () => CalendarDetailWidthCharsPropertyInfo
data () => CalendarGetDateMethodInfo
data () => CalendarGetDayIsMarkedMethodInfo
data () => CalendarGetDetailHeightRowsMethodInfo
data () => CalendarGetDetailWidthCharsMethodInfo
data () => CalendarGetDisplayOptionsMethodInfo
data () => CalendarMarkDayMethodInfo
data () => CalendarMonthChangedSignalInfo
data () => CalendarMonthPropertyInfo
data () => CalendarNextMonthSignalInfo
data () => CalendarNextYearSignalInfo
data () => CalendarNoMonthChangePropertyInfo
data () => CalendarPrevMonthSignalInfo
data () => CalendarPrevYearSignalInfo
data () => CalendarSelectDayMethodInfo
data () => CalendarSelectMonthMethodInfo
data () => CalendarSetDetailFuncMethodInfo
data () => CalendarSetDetailHeightRowsMethodInfo
data () => CalendarSetDetailWidthCharsMethodInfo
data () => CalendarSetDisplayOptionsMethodInfo
data () => CalendarShowDayNamesPropertyInfo
data () => CalendarShowDetailsPropertyInfo
data () => CalendarShowHeadingPropertyInfo
data () => CalendarShowWeekNumbersPropertyInfo
data () => CalendarUnmarkDayMethodInfo
data () => CalendarYearPropertyInfo
type family ResolveCalendarMethod (t :: Symbol) o
type family ResolveCellAccessibleMethod (t :: Symbol) o
data () => CellAreaActivateCellMethodInfo
data () => CellAreaActivateMethodInfo
data () => CellAreaAddEditableSignalInfo
data () => CellAreaAddFocusSiblingMethodInfo
data () => CellAreaAddMethodInfo
data () => CellAreaApplyAttributesMethodInfo
data () => CellAreaApplyAttributesSignalInfo
data () => CellAreaAttributeConnectMethodInfo
data () => CellAreaAttributeDisconnectMethodInfo
data () => CellAreaAttributeGetColumnMethodInfo
data () => CellAreaCellGetPropertyMethodInfo
data () => CellAreaCellSetPropertyMethodInfo
data () => CellAreaCopyContextMethodInfo
data () => CellAreaCreateContextMethodInfo
data () => CellAreaEditWidgetPropertyInfo
data () => CellAreaEditedCellPropertyInfo
data () => CellAreaEventMethodInfo
data () => CellAreaFocusCellPropertyInfo
data () => CellAreaFocusChangedSignalInfo
data () => CellAreaFocusMethodInfo
data () => CellAreaForeachAllocMethodInfo
data () => CellAreaForeachMethodInfo
data () => CellAreaGetCellAllocationMethodInfo
data () => CellAreaGetCellAtPositionMethodInfo
data () => CellAreaGetCurrentPathStringMethodInfo
data () => CellAreaGetEditWidgetMethodInfo
data () => CellAreaGetEditedCellMethodInfo
data () => CellAreaGetFocusCellMethodInfo
data () => CellAreaGetFocusFromSiblingMethodInfo
data () => CellAreaGetFocusSiblingsMethodInfo
data () => CellAreaGetPreferredHeightForWidthMethodInfo
data () => CellAreaGetPreferredHeightMethodInfo
data () => CellAreaGetPreferredWidthForHeightMethodInfo
data () => CellAreaGetPreferredWidthMethodInfo
data () => CellAreaGetRequestModeMethodInfo
data () => CellAreaHasRendererMethodInfo
data () => CellAreaInnerCellAreaMethodInfo
data () => CellAreaIsActivatableMethodInfo
data () => CellAreaIsFocusSiblingMethodInfo
data () => CellAreaRemoveEditableSignalInfo
data () => CellAreaRemoveFocusSiblingMethodInfo
data () => CellAreaRemoveMethodInfo
data () => CellAreaRenderMethodInfo
data () => CellAreaRequestRendererMethodInfo
data () => CellAreaSetFocusCellMethodInfo
data () => CellAreaStopEditingMethodInfo
type family ResolveCellAreaMethod (t :: Symbol) o
data () => CellAreaBoxGetSpacingMethodInfo
data () => CellAreaBoxPackEndMethodInfo
data () => CellAreaBoxPackStartMethodInfo
data () => CellAreaBoxSetSpacingMethodInfo
data () => CellAreaBoxSpacingPropertyInfo
type family ResolveCellAreaBoxMethod (t :: Symbol) o
data () => CellAreaContextAllocateMethodInfo
data () => CellAreaContextAreaPropertyInfo
data () => CellAreaContextGetAllocationMethodInfo
data () => CellAreaContextGetAreaMethodInfo
data () => CellAreaContextGetPreferredHeightForWidthMethodInfo
data () => CellAreaContextGetPreferredHeightMethodInfo
data () => CellAreaContextGetPreferredWidthForHeightMethodInfo
data () => CellAreaContextGetPreferredWidthMethodInfo
data () => CellAreaContextMinimumHeightPropertyInfo
data () => CellAreaContextMinimumWidthPropertyInfo
data () => CellAreaContextNaturalHeightPropertyInfo
data () => CellAreaContextNaturalWidthPropertyInfo
data () => CellAreaContextPushPreferredHeightMethodInfo
data () => CellAreaContextPushPreferredWidthMethodInfo
data () => CellAreaContextResetMethodInfo
type family ResolveCellAreaContextMethod (t :: Symbol) o
data () => CellRendererActivateMethodInfo
data () => CellRendererCellBackgroundGdkPropertyInfo
data () => CellRendererCellBackgroundPropertyInfo
data () => CellRendererCellBackgroundRgbaPropertyInfo
data () => CellRendererCellBackgroundSetPropertyInfo
data () => CellRendererEditingCanceledSignalInfo
data () => CellRendererEditingPropertyInfo
data () => CellRendererEditingStartedSignalInfo
data () => CellRendererGetAlignedAreaMethodInfo
data () => CellRendererGetAlignmentMethodInfo
data () => CellRendererGetFixedSizeMethodInfo
data () => CellRendererGetPaddingMethodInfo
data () => CellRendererGetPreferredHeightForWidthMethodInfo
data () => CellRendererGetPreferredHeightMethodInfo
data () => CellRendererGetPreferredSizeMethodInfo
data () => CellRendererGetPreferredWidthForHeightMethodInfo
data () => CellRendererGetPreferredWidthMethodInfo
data () => CellRendererGetRequestModeMethodInfo
data () => CellRendererGetSensitiveMethodInfo
data () => CellRendererGetSizeMethodInfo
data () => CellRendererGetStateMethodInfo
data () => CellRendererGetVisibleMethodInfo
data () => CellRendererHeightPropertyInfo
data () => CellRendererIsActivatableMethodInfo
data () => CellRendererIsExpandedPropertyInfo
data () => CellRendererIsExpanderPropertyInfo
data () => CellRendererModePropertyInfo
data () => CellRendererRenderMethodInfo
data () => CellRendererSensitivePropertyInfo
data () => CellRendererSetAlignmentMethodInfo
data () => CellRendererSetFixedSizeMethodInfo
data () => CellRendererSetPaddingMethodInfo
data () => CellRendererSetSensitiveMethodInfo
data () => CellRendererSetVisibleMethodInfo
data () => CellRendererStartEditingMethodInfo
data () => CellRendererStopEditingMethodInfo
data () => CellRendererVisiblePropertyInfo
data () => CellRendererWidthPropertyInfo
data () => CellRendererXalignPropertyInfo
data () => CellRendererXpadPropertyInfo
data () => CellRendererYalignPropertyInfo
data () => CellRendererYpadPropertyInfo
type family ResolveCellRendererMethod (t :: Symbol) o
data () => CellRendererAccelAccelClearedSignalInfo
data () => CellRendererAccelAccelEditedSignalInfo
data () => CellRendererAccelAccelKeyPropertyInfo
data () => CellRendererAccelAccelModePropertyInfo
data () => CellRendererAccelAccelModsPropertyInfo
data () => CellRendererAccelKeycodePropertyInfo
type family ResolveCellRendererAccelMethod (t :: Symbol) o
data () => CellRendererComboChangedSignalInfo
data () => CellRendererComboHasEntryPropertyInfo
data () => CellRendererComboModelPropertyInfo
data () => CellRendererComboTextColumnPropertyInfo
type family ResolveCellRendererComboMethod (t :: Symbol) o
data () => CellRendererPixbufFollowStatePropertyInfo
data () => CellRendererPixbufGiconPropertyInfo
data () => CellRendererPixbufIconNamePropertyInfo
data () => CellRendererPixbufPixbufExpanderClosedPropertyInfo
data () => CellRendererPixbufPixbufExpanderOpenPropertyInfo
data () => CellRendererPixbufPixbufPropertyInfo
data () => CellRendererPixbufStockDetailPropertyInfo
data () => CellRendererPixbufStockIdPropertyInfo
data () => CellRendererPixbufStockSizePropertyInfo
data () => CellRendererPixbufSurfacePropertyInfo
type family ResolveCellRendererPixbufMethod (t :: Symbol) o
data () => CellRendererProgressInvertedPropertyInfo
data () => CellRendererProgressPulsePropertyInfo
data () => CellRendererProgressTextPropertyInfo
data () => CellRendererProgressTextXalignPropertyInfo
data () => CellRendererProgressTextYalignPropertyInfo
data () => CellRendererProgressValuePropertyInfo
type family ResolveCellRendererProgressMethod (t :: Symbol) o
data () => CellRendererSpinAdjustmentPropertyInfo
data () => CellRendererSpinClimbRatePropertyInfo
data () => CellRendererSpinDigitsPropertyInfo
type family ResolveCellRendererSpinMethod (t :: Symbol) o
data () => CellRendererSpinnerActivePropertyInfo
data () => CellRendererSpinnerPulsePropertyInfo
data () => CellRendererSpinnerSizePropertyInfo
type family ResolveCellRendererSpinnerMethod (t :: Symbol) o
data () => CellRendererTextAlignSetPropertyInfo
data () => CellRendererTextAlignmentPropertyInfo
data () => CellRendererTextAttributesPropertyInfo
data () => CellRendererTextBackgroundGdkPropertyInfo
data () => CellRendererTextBackgroundPropertyInfo
data () => CellRendererTextBackgroundRgbaPropertyInfo
data () => CellRendererTextBackgroundSetPropertyInfo
data () => CellRendererTextEditablePropertyInfo
data () => CellRendererTextEditableSetPropertyInfo
data () => CellRendererTextEditedSignalInfo
data () => CellRendererTextEllipsizePropertyInfo
data () => CellRendererTextEllipsizeSetPropertyInfo
data () => CellRendererTextFamilyPropertyInfo
data () => CellRendererTextFamilySetPropertyInfo
data () => CellRendererTextFontDescPropertyInfo
data () => CellRendererTextFontPropertyInfo
data () => CellRendererTextForegroundGdkPropertyInfo
data () => CellRendererTextForegroundPropertyInfo
data () => CellRendererTextForegroundRgbaPropertyInfo
data () => CellRendererTextForegroundSetPropertyInfo
data () => CellRendererTextLanguagePropertyInfo
data () => CellRendererTextLanguageSetPropertyInfo
data () => CellRendererTextMarkupPropertyInfo
data () => CellRendererTextMaxWidthCharsPropertyInfo
data () => CellRendererTextPlaceholderTextPropertyInfo
data () => CellRendererTextRisePropertyInfo
data () => CellRendererTextRiseSetPropertyInfo
data () => CellRendererTextScalePropertyInfo
data () => CellRendererTextScaleSetPropertyInfo
data () => CellRendererTextSetFixedHeightFromFontMethodInfo
data () => CellRendererTextSingleParagraphModePropertyInfo
data () => CellRendererTextSizePointsPropertyInfo
data () => CellRendererTextSizePropertyInfo
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
type family ResolveCellRendererTextMethod (t :: Symbol) o
data () => CellRendererToggleActivatablePropertyInfo
data () => CellRendererToggleActivePropertyInfo
data () => CellRendererToggleGetActivatableMethodInfo
data () => CellRendererToggleGetActiveMethodInfo
data () => CellRendererToggleGetRadioMethodInfo
data () => CellRendererToggleInconsistentPropertyInfo
data () => CellRendererToggleIndicatorSizePropertyInfo
data () => CellRendererToggleRadioPropertyInfo
data () => CellRendererToggleSetActivatableMethodInfo
data () => CellRendererToggleSetActiveMethodInfo
data () => CellRendererToggleSetRadioMethodInfo
data () => CellRendererToggleToggledSignalInfo
type family ResolveCellRendererToggleMethod (t :: Symbol) o
data () => CellViewBackgroundGdkPropertyInfo
data () => CellViewBackgroundPropertyInfo
data () => CellViewBackgroundRgbaPropertyInfo
data () => CellViewBackgroundSetPropertyInfo
data () => CellViewCellAreaContextPropertyInfo
data () => CellViewCellAreaPropertyInfo
data () => CellViewDrawSensitivePropertyInfo
data () => CellViewFitModelPropertyInfo
data () => CellViewGetDisplayedRowMethodInfo
data () => CellViewGetDrawSensitiveMethodInfo
data () => CellViewGetFitModelMethodInfo
data () => CellViewGetModelMethodInfo
data () => CellViewGetSizeOfRowMethodInfo
data () => CellViewModelPropertyInfo
data () => CellViewSetBackgroundColorMethodInfo
data () => CellViewSetBackgroundRgbaMethodInfo
data () => CellViewSetDisplayedRowMethodInfo
data () => CellViewSetDrawSensitiveMethodInfo
data () => CellViewSetFitModelMethodInfo
data () => CellViewSetModelMethodInfo
type family ResolveCellViewMethod (t :: Symbol) o
type family ResolveCheckButtonMethod (t :: Symbol) o
data () => CheckMenuItemActivePropertyInfo
data () => CheckMenuItemDrawAsRadioPropertyInfo
data () => CheckMenuItemGetActiveMethodInfo
data () => CheckMenuItemGetDrawAsRadioMethodInfo
data () => CheckMenuItemGetInconsistentMethodInfo
data () => CheckMenuItemInconsistentPropertyInfo
data () => CheckMenuItemSetActiveMethodInfo
data () => CheckMenuItemSetDrawAsRadioMethodInfo
data () => CheckMenuItemSetInconsistentMethodInfo
data () => CheckMenuItemToggledMethodInfo
data () => CheckMenuItemToggledSignalInfo
type family ResolveCheckMenuItemMethod (t :: Symbol) o
type family ResolveCheckMenuItemAccessibleMethod (t :: Symbol) o
data () => ClipboardClearMethodInfo
data () => ClipboardGetDisplayMethodInfo
data () => ClipboardGetOwnerMethodInfo
data () => ClipboardGetSelectionMethodInfo
data () => ClipboardOwnerChangeSignalInfo
data () => ClipboardRequestContentsMethodInfo
data () => ClipboardRequestImageMethodInfo
data () => ClipboardRequestRichTextMethodInfo
data () => ClipboardRequestTargetsMethodInfo
data () => ClipboardRequestTextMethodInfo
data () => ClipboardRequestUrisMethodInfo
data () => ClipboardSetCanStoreMethodInfo
data () => ClipboardSetImageMethodInfo
data () => ClipboardSetTextMethodInfo
data () => ClipboardStoreMethodInfo
data () => ClipboardWaitForContentsMethodInfo
data () => ClipboardWaitForImageMethodInfo
data () => ClipboardWaitForRichTextMethodInfo
data () => ClipboardWaitForTargetsMethodInfo
data () => ClipboardWaitForTextMethodInfo
data () => ClipboardWaitForUrisMethodInfo
data () => ClipboardWaitIsImageAvailableMethodInfo
data () => ClipboardWaitIsRichTextAvailableMethodInfo
data () => ClipboardWaitIsTargetAvailableMethodInfo
data () => ClipboardWaitIsTextAvailableMethodInfo
data () => ClipboardWaitIsUrisAvailableMethodInfo
type family ResolveClipboardMethod (t :: Symbol) o
data () => ColorButtonAlphaPropertyInfo
data () => ColorButtonColorPropertyInfo
data () => ColorButtonColorSetSignalInfo
data () => ColorButtonGetAlphaMethodInfo
data () => ColorButtonGetColorMethodInfo
data () => ColorButtonGetTitleMethodInfo
data () => ColorButtonGetUseAlphaMethodInfo
data () => ColorButtonRgbaPropertyInfo
data () => ColorButtonSetAlphaMethodInfo
data () => ColorButtonSetColorMethodInfo
data () => ColorButtonSetTitleMethodInfo
data () => ColorButtonSetUseAlphaMethodInfo
data () => ColorButtonShowEditorPropertyInfo
data () => ColorButtonTitlePropertyInfo
data () => ColorButtonUseAlphaPropertyInfo
type family ResolveColorButtonMethod (t :: Symbol) o
data () => ColorChooserDialogShowEditorPropertyInfo
type family ResolveColorChooserDialogMethod (t :: Symbol) o
data () => ColorChooserWidgetShowEditorPropertyInfo
type family ResolveColorChooserWidgetMethod (t :: Symbol) o
data () => ColorSelectionColorChangedSignalInfo
data () => ColorSelectionCurrentAlphaPropertyInfo
data () => ColorSelectionCurrentColorPropertyInfo
data () => ColorSelectionCurrentRgbaPropertyInfo
data () => ColorSelectionGetCurrentAlphaMethodInfo
data () => ColorSelectionGetCurrentColorMethodInfo
data () => ColorSelectionGetCurrentRgbaMethodInfo
data () => ColorSelectionGetHasOpacityControlMethodInfo
data () => ColorSelectionGetHasPaletteMethodInfo
data () => ColorSelectionGetPreviousAlphaMethodInfo
data () => ColorSelectionGetPreviousColorMethodInfo
data () => ColorSelectionGetPreviousRgbaMethodInfo
data () => ColorSelectionHasOpacityControlPropertyInfo
data () => ColorSelectionHasPalettePropertyInfo
data () => ColorSelectionIsAdjustingMethodInfo
data () => ColorSelectionSetCurrentAlphaMethodInfo
data () => ColorSelectionSetCurrentColorMethodInfo
data () => ColorSelectionSetCurrentRgbaMethodInfo
data () => ColorSelectionSetHasOpacityControlMethodInfo
data () => ColorSelectionSetHasPaletteMethodInfo
data () => ColorSelectionSetPreviousAlphaMethodInfo
data () => ColorSelectionSetPreviousColorMethodInfo
data () => ColorSelectionSetPreviousRgbaMethodInfo
type family ResolveColorSelectionMethod (t :: Symbol) o
data () => ColorSelectionDialogCancelButtonPropertyInfo
data () => ColorSelectionDialogColorSelectionPropertyInfo
data () => ColorSelectionDialogGetColorSelectionMethodInfo
data () => ColorSelectionDialogHelpButtonPropertyInfo
data () => ColorSelectionDialogOkButtonPropertyInfo
type family ResolveColorSelectionDialogMethod (t :: Symbol) o
data () => ComboBoxActiveIdPropertyInfo
data () => ComboBoxActivePropertyInfo
data () => ComboBoxAddTearoffsPropertyInfo
data () => ComboBoxButtonSensitivityPropertyInfo
data () => ComboBoxCellAreaPropertyInfo
data () => ComboBoxChangedSignalInfo
data () => ComboBoxColumnSpanColumnPropertyInfo
data () => ComboBoxEntryTextColumnPropertyInfo
data () => ComboBoxFormatEntryTextSignalInfo
data () => ComboBoxGetActiveIdMethodInfo
data () => ComboBoxGetActiveIterMethodInfo
data () => ComboBoxGetActiveMethodInfo
data () => ComboBoxGetAddTearoffsMethodInfo
data () => ComboBoxGetButtonSensitivityMethodInfo
data () => ComboBoxGetColumnSpanColumnMethodInfo
data () => ComboBoxGetEntryTextColumnMethodInfo
data () => ComboBoxGetFocusOnClickMethodInfo
data () => ComboBoxGetHasEntryMethodInfo
data () => ComboBoxGetIdColumnMethodInfo
data () => ComboBoxGetModelMethodInfo
data () => ComboBoxGetPopupAccessibleMethodInfo
data () => ComboBoxGetPopupFixedWidthMethodInfo
data () => ComboBoxGetRowSpanColumnMethodInfo
data () => ComboBoxGetTitleMethodInfo
data () => ComboBoxGetWrapWidthMethodInfo
data () => ComboBoxHasEntryPropertyInfo
data () => ComboBoxHasFramePropertyInfo
data () => ComboBoxIdColumnPropertyInfo
data () => ComboBoxModelPropertyInfo
data () => ComboBoxMoveActiveSignalInfo
data () => ComboBoxPopdownMethodInfo
data () => ComboBoxPopdownSignalInfo
data () => ComboBoxPopupFixedWidthPropertyInfo
data () => ComboBoxPopupForDeviceMethodInfo
data () => ComboBoxPopupMethodInfo
data () => ComboBoxPopupShownPropertyInfo
data () => ComboBoxPopupSignalInfo
data () => ComboBoxRowSpanColumnPropertyInfo
data () => ComboBoxSetActiveIdMethodInfo
data () => ComboBoxSetActiveIterMethodInfo
data () => ComboBoxSetActiveMethodInfo
data () => ComboBoxSetAddTearoffsMethodInfo
data () => ComboBoxSetButtonSensitivityMethodInfo
data () => ComboBoxSetColumnSpanColumnMethodInfo
data () => ComboBoxSetEntryTextColumnMethodInfo
data () => ComboBoxSetFocusOnClickMethodInfo
data () => ComboBoxSetIdColumnMethodInfo
data () => ComboBoxSetModelMethodInfo
data () => ComboBoxSetPopupFixedWidthMethodInfo
data () => ComboBoxSetRowSeparatorFuncMethodInfo
data () => ComboBoxSetRowSpanColumnMethodInfo
data () => ComboBoxSetTitleMethodInfo
data () => ComboBoxSetWrapWidthMethodInfo
data () => ComboBoxTearoffTitlePropertyInfo
data () => ComboBoxWrapWidthPropertyInfo
type family ResolveComboBoxMethod (t :: Symbol) o
type family ResolveComboBoxAccessibleMethod (t :: Symbol) o
data () => ComboBoxTextAppendMethodInfo
data () => ComboBoxTextAppendTextMethodInfo
data () => ComboBoxTextGetActiveTextMethodInfo
data () => ComboBoxTextInsertMethodInfo
data () => ComboBoxTextInsertTextMethodInfo
data () => ComboBoxTextPrependMethodInfo
data () => ComboBoxTextPrependTextMethodInfo
data () => ComboBoxTextRemoveAllMethodInfo
data () => ComboBoxTextRemoveMethodInfo
type family ResolveComboBoxTextMethod (t :: Symbol) o
data () => ContainerAddMethodInfo
data () => ContainerAddSignalInfo
data () => ContainerBorderWidthPropertyInfo
data () => ContainerCheckResizeMethodInfo
data () => ContainerCheckResizeSignalInfo
data () => ContainerChildGetPropertyMethodInfo
data () => ContainerChildNotifyByPspecMethodInfo
data () => ContainerChildNotifyMethodInfo
data () => ContainerChildPropertyInfo
data () => ContainerChildSetPropertyMethodInfo
data () => ContainerChildTypeMethodInfo
data () => ContainerForallMethodInfo
data () => ContainerForeachMethodInfo
data () => ContainerGetBorderWidthMethodInfo
data () => ContainerGetChildrenMethodInfo
data () => ContainerGetFocusChainMethodInfo
data () => ContainerGetFocusChildMethodInfo
data () => ContainerGetFocusHadjustmentMethodInfo
data () => ContainerGetFocusVadjustmentMethodInfo
data () => ContainerGetPathForChildMethodInfo
data () => ContainerGetResizeModeMethodInfo
data () => ContainerPropagateDrawMethodInfo
data () => ContainerRemoveMethodInfo
data () => ContainerRemoveSignalInfo
data () => ContainerResizeChildrenMethodInfo
data () => ContainerResizeModePropertyInfo
data () => ContainerSetBorderWidthMethodInfo
data () => ContainerSetFocusChainMethodInfo
data () => ContainerSetFocusChildMethodInfo
data () => ContainerSetFocusChildSignalInfo
data () => ContainerSetFocusHadjustmentMethodInfo
data () => ContainerSetFocusVadjustmentMethodInfo
data () => ContainerSetReallocateRedrawsMethodInfo
data () => ContainerSetResizeModeMethodInfo
data () => ContainerUnsetFocusChainMethodInfo
type family ResolveContainerMethod (t :: Symbol) o
type family ResolveContainerAccessibleMethod (t :: Symbol) o
data () => ContainerCellAccessibleAddChildMethodInfo
data () => ContainerCellAccessibleGetChildrenMethodInfo
data () => ContainerCellAccessibleRemoveChildMethodInfo
type family ResolveContainerCellAccessibleMethod (t :: Symbol) o
data () => CssProviderLoadFromDataMethodInfo
data () => CssProviderLoadFromFileMethodInfo
data () => CssProviderLoadFromPathMethodInfo
data () => CssProviderLoadFromResourceMethodInfo
data () => CssProviderParsingErrorSignalInfo
data () => CssProviderToStringMethodInfo
type family ResolveCssProviderMethod (t :: Symbol) o
data () => DialogAddActionWidgetMethodInfo
data () => DialogAddButtonMethodInfo
data () => DialogCloseSignalInfo
data () => DialogGetActionAreaMethodInfo
data () => DialogGetContentAreaMethodInfo
data () => DialogGetHeaderBarMethodInfo
data () => DialogGetResponseForWidgetMethodInfo
data () => DialogGetWidgetForResponseMethodInfo
data () => DialogResponseMethodInfo
data () => DialogResponseSignalInfo
data () => DialogRunMethodInfo
data () => DialogSetAlternativeButtonOrderFromArrayMethodInfo
data () => DialogSetDefaultResponseMethodInfo
data () => DialogSetResponseSensitiveMethodInfo
data () => DialogUseHeaderBarPropertyInfo
type family ResolveDialogMethod (t :: Symbol) o
type family ResolveDrawingAreaMethod (t :: Symbol) o
data () => EntryActivateSignalInfo
data () => EntryActivatesDefaultPropertyInfo
data () => EntryAttributesPropertyInfo
data () => EntryBackspaceSignalInfo
data () => EntryBufferPropertyInfo
data () => EntryCapsLockWarningPropertyInfo
data () => EntryCompletionPropertyInfo
data () => EntryCopyClipboardSignalInfo
data () => EntryCursorPositionPropertyInfo
data () => EntryCutClipboardSignalInfo
data () => EntryDeleteFromCursorSignalInfo
data () => EntryEditablePropertyInfo
data () => EntryEnableEmojiCompletionPropertyInfo
data () => EntryGetActivatesDefaultMethodInfo
data () => EntryGetAlignmentMethodInfo
data () => EntryGetAttributesMethodInfo
data () => EntryGetBufferMethodInfo
data () => EntryGetCompletionMethodInfo
data () => EntryGetCurrentIconDragSourceMethodInfo
data () => EntryGetCursorHadjustmentMethodInfo
data () => EntryGetHasFrameMethodInfo
data () => EntryGetIconActivatableMethodInfo
data () => EntryGetIconAreaMethodInfo
data () => EntryGetIconAtPosMethodInfo
data () => EntryGetIconGiconMethodInfo
data () => EntryGetIconNameMethodInfo
data () => EntryGetIconPixbufMethodInfo
data () => EntryGetIconSensitiveMethodInfo
data () => EntryGetIconStockMethodInfo
data () => EntryGetIconStorageTypeMethodInfo
data () => EntryGetIconTooltipMarkupMethodInfo
data () => EntryGetIconTooltipTextMethodInfo
data () => EntryGetInnerBorderMethodInfo
data () => EntryGetInputHintsMethodInfo
data () => EntryGetInputPurposeMethodInfo
data () => EntryGetInvisibleCharMethodInfo
data () => EntryGetLayoutMethodInfo
data () => EntryGetLayoutOffsetsMethodInfo
data () => EntryGetMaxLengthMethodInfo
data () => EntryGetMaxWidthCharsMethodInfo
data () => EntryGetOverwriteModeMethodInfo
data () => EntryGetPlaceholderTextMethodInfo
data () => EntryGetProgressFractionMethodInfo
data () => EntryGetProgressPulseStepMethodInfo
data () => EntryGetTabsMethodInfo
data () => EntryGetTextAreaMethodInfo
data () => EntryGetTextLengthMethodInfo
data () => EntryGetTextMethodInfo
data () => EntryGetVisibilityMethodInfo
data () => EntryGetWidthCharsMethodInfo
data () => EntryGrabFocusWithoutSelectingMethodInfo
data () => EntryHasFramePropertyInfo
data () => EntryIconPressSignalInfo
data () => EntryIconReleaseSignalInfo
data () => EntryImContextFilterKeypressMethodInfo
data () => EntryImModulePropertyInfo
data () => EntryInnerBorderPropertyInfo
data () => EntryInputHintsPropertyInfo
data () => EntryInputPurposePropertyInfo
data () => EntryInsertAtCursorSignalInfo
data () => EntryInsertEmojiSignalInfo
data () => EntryInvisibleCharPropertyInfo
data () => EntryInvisibleCharSetPropertyInfo
data () => EntryLayoutIndexToTextIndexMethodInfo
data () => EntryMaxLengthPropertyInfo
data () => EntryMaxWidthCharsPropertyInfo
data () => EntryMoveCursorSignalInfo
data () => EntryOverwriteModePropertyInfo
data () => EntryPasteClipboardSignalInfo
data () => EntryPlaceholderTextPropertyInfo
data () => EntryPopulateAllPropertyInfo
data () => EntryPopulatePopupSignalInfo
data () => EntryPreeditChangedSignalInfo
data () => EntryPrimaryIconActivatablePropertyInfo
data () => EntryPrimaryIconGiconPropertyInfo
data () => EntryPrimaryIconNamePropertyInfo
data () => EntryPrimaryIconPixbufPropertyInfo
data () => EntryPrimaryIconSensitivePropertyInfo
data () => EntryPrimaryIconStockPropertyInfo
data () => EntryPrimaryIconStorageTypePropertyInfo
data () => EntryPrimaryIconTooltipMarkupPropertyInfo
data () => EntryPrimaryIconTooltipTextPropertyInfo
data () => EntryProgressFractionPropertyInfo
data () => EntryProgressPulseMethodInfo
data () => EntryProgressPulseStepPropertyInfo
data () => EntryResetImContextMethodInfo
data () => EntryScrollOffsetPropertyInfo
data () => EntrySecondaryIconActivatablePropertyInfo
data () => EntrySecondaryIconGiconPropertyInfo
data () => EntrySecondaryIconNamePropertyInfo
data () => EntrySecondaryIconPixbufPropertyInfo
data () => EntrySecondaryIconSensitivePropertyInfo
data () => EntrySecondaryIconStockPropertyInfo
data () => EntrySecondaryIconStorageTypePropertyInfo
data () => EntrySecondaryIconTooltipMarkupPropertyInfo
data () => EntrySecondaryIconTooltipTextPropertyInfo
data () => EntrySelectionBoundPropertyInfo
data () => EntrySetActivatesDefaultMethodInfo
data () => EntrySetAlignmentMethodInfo
data () => EntrySetAttributesMethodInfo
data () => EntrySetBufferMethodInfo
data () => EntrySetCompletionMethodInfo
data () => EntrySetCursorHadjustmentMethodInfo
data () => EntrySetHasFrameMethodInfo
data () => EntrySetIconActivatableMethodInfo
data () => EntrySetIconDragSourceMethodInfo
data () => EntrySetIconFromGiconMethodInfo
data () => EntrySetIconFromIconNameMethodInfo
data () => EntrySetIconFromPixbufMethodInfo
data () => EntrySetIconFromStockMethodInfo
data () => EntrySetIconSensitiveMethodInfo
data () => EntrySetIconTooltipMarkupMethodInfo
data () => EntrySetIconTooltipTextMethodInfo
data () => EntrySetInnerBorderMethodInfo
data () => EntrySetInputHintsMethodInfo
data () => EntrySetInputPurposeMethodInfo
data () => EntrySetInvisibleCharMethodInfo
data () => EntrySetMaxLengthMethodInfo
data () => EntrySetMaxWidthCharsMethodInfo
data () => EntrySetOverwriteModeMethodInfo
data () => EntrySetPlaceholderTextMethodInfo
data () => EntrySetProgressFractionMethodInfo
data () => EntrySetProgressPulseStepMethodInfo
data () => EntrySetTabsMethodInfo
data () => EntrySetTextMethodInfo
data () => EntrySetVisibilityMethodInfo
data () => EntrySetWidthCharsMethodInfo
data () => EntryShadowTypePropertyInfo
data () => EntryShowEmojiIconPropertyInfo
data () => EntryTabsPropertyInfo
data () => EntryTextIndexToLayoutIndexMethodInfo
data () => EntryTextLengthPropertyInfo
data () => EntryTextPropertyInfo
data () => EntryToggleOverwriteSignalInfo
data () => EntryTruncateMultilinePropertyInfo
data () => EntryUnsetInvisibleCharMethodInfo
data () => EntryVisibilityPropertyInfo
data () => EntryWidthCharsPropertyInfo
data () => EntryXalignPropertyInfo
type family ResolveEntryMethod (t :: Symbol) o
type family ResolveEntryAccessibleMethod (t :: Symbol) o
data () => EntryBufferDeleteTextMethodInfo
data () => EntryBufferDeletedTextSignalInfo
data () => EntryBufferEmitDeletedTextMethodInfo
data () => EntryBufferEmitInsertedTextMethodInfo
data () => EntryBufferGetBytesMethodInfo
data () => EntryBufferGetLengthMethodInfo
data () => EntryBufferGetMaxLengthMethodInfo
data () => EntryBufferGetTextMethodInfo
data () => EntryBufferInsertTextMethodInfo
data () => EntryBufferInsertedTextSignalInfo
data () => EntryBufferLengthPropertyInfo
data () => EntryBufferMaxLengthPropertyInfo
data () => EntryBufferSetMaxLengthMethodInfo
data () => EntryBufferSetTextMethodInfo
data () => EntryBufferTextPropertyInfo
type family ResolveEntryBufferMethod (t :: Symbol) o
data () => EntryCompletionActionActivatedSignalInfo
data () => EntryCompletionCellAreaPropertyInfo
data () => EntryCompletionCompleteMethodInfo
data () => EntryCompletionComputePrefixMethodInfo
data () => EntryCompletionCursorOnMatchSignalInfo
data () => EntryCompletionDeleteActionMethodInfo
data () => EntryCompletionGetCompletionPrefixMethodInfo
data () => EntryCompletionGetEntryMethodInfo
data () => EntryCompletionGetInlineCompletionMethodInfo
data () => EntryCompletionGetInlineSelectionMethodInfo
data () => EntryCompletionGetMinimumKeyLengthMethodInfo
data () => EntryCompletionGetModelMethodInfo
data () => EntryCompletionGetPopupCompletionMethodInfo
data () => EntryCompletionGetPopupSetWidthMethodInfo
data () => EntryCompletionGetPopupSingleMatchMethodInfo
data () => EntryCompletionGetTextColumnMethodInfo
data () => EntryCompletionInlineCompletionPropertyInfo
data () => EntryCompletionInlineSelectionPropertyInfo
data () => EntryCompletionInsertActionMarkupMethodInfo
data () => EntryCompletionInsertActionTextMethodInfo
data () => EntryCompletionInsertPrefixMethodInfo
data () => EntryCompletionInsertPrefixSignalInfo
data () => EntryCompletionMatchSelectedSignalInfo
data () => EntryCompletionMinimumKeyLengthPropertyInfo
data () => EntryCompletionModelPropertyInfo
data () => EntryCompletionNoMatchesSignalInfo
data () => EntryCompletionPopupCompletionPropertyInfo
data () => EntryCompletionPopupSetWidthPropertyInfo
data () => EntryCompletionPopupSingleMatchPropertyInfo
data () => EntryCompletionSetInlineCompletionMethodInfo
data () => EntryCompletionSetInlineSelectionMethodInfo
data () => EntryCompletionSetMatchFuncMethodInfo
data () => EntryCompletionSetMinimumKeyLengthMethodInfo
data () => EntryCompletionSetModelMethodInfo
data () => EntryCompletionSetPopupCompletionMethodInfo
data () => EntryCompletionSetPopupSetWidthMethodInfo
data () => EntryCompletionSetPopupSingleMatchMethodInfo
data () => EntryCompletionSetTextColumnMethodInfo
data () => EntryCompletionTextColumnPropertyInfo
type family ResolveEntryCompletionMethod (t :: Symbol) o
type family ResolveEntryIconAccessibleMethod (t :: Symbol) o
data () => EventBoxAboveChildPropertyInfo
data () => EventBoxGetAboveChildMethodInfo
data () => EventBoxGetVisibleWindowMethodInfo
data () => EventBoxSetAboveChildMethodInfo
data () => EventBoxSetVisibleWindowMethodInfo
data () => EventBoxVisibleWindowPropertyInfo
type family ResolveEventBoxMethod (t :: Symbol) o
data () => EventControllerGetPropagationPhaseMethodInfo
data () => EventControllerGetWidgetMethodInfo
data () => EventControllerHandleEventMethodInfo
data () => EventControllerPropagationPhasePropertyInfo
data () => EventControllerResetMethodInfo
data () => EventControllerSetPropagationPhaseMethodInfo
data () => EventControllerWidgetPropertyInfo
type family ResolveEventControllerMethod (t :: Symbol) o
data () => EventControllerKeyFocusInSignalInfo
data () => EventControllerKeyFocusOutSignalInfo
data () => EventControllerKeyForwardMethodInfo
data () => EventControllerKeyGetGroupMethodInfo
data () => EventControllerKeyGetImContextMethodInfo
data () => EventControllerKeyImUpdateSignalInfo
data () => EventControllerKeyKeyPressedSignalInfo
data () => EventControllerKeyKeyReleasedSignalInfo
data () => EventControllerKeyModifiersSignalInfo
data () => EventControllerKeySetImContextMethodInfo
type family ResolveEventControllerKeyMethod (t :: Symbol) o
data () => EventControllerMotionEnterSignalInfo
data () => EventControllerMotionLeaveSignalInfo
data () => EventControllerMotionMotionSignalInfo
type family ResolveEventControllerMotionMethod (t :: Symbol) o
data () => EventControllerScrollDecelerateSignalInfo
data () => EventControllerScrollFlagsPropertyInfo
data () => EventControllerScrollGetFlagsMethodInfo
data () => EventControllerScrollScrollBeginSignalInfo
data () => EventControllerScrollScrollEndSignalInfo
data () => EventControllerScrollScrollSignalInfo
data () => EventControllerScrollSetFlagsMethodInfo
type family ResolveEventControllerScrollMethod (t :: Symbol) o
data () => ExpanderActivateSignalInfo
data () => ExpanderExpandedPropertyInfo
data () => ExpanderGetExpandedMethodInfo
data () => ExpanderGetLabelFillMethodInfo
data () => ExpanderGetLabelMethodInfo
data () => ExpanderGetLabelWidgetMethodInfo
data () => ExpanderGetResizeToplevelMethodInfo
data () => ExpanderGetSpacingMethodInfo
data () => ExpanderGetUseMarkupMethodInfo
data () => ExpanderGetUseUnderlineMethodInfo
data () => ExpanderLabelFillPropertyInfo
data () => ExpanderLabelPropertyInfo
data () => ExpanderLabelWidgetPropertyInfo
data () => ExpanderResizeToplevelPropertyInfo
data () => ExpanderSetExpandedMethodInfo
data () => ExpanderSetLabelFillMethodInfo
data () => ExpanderSetLabelMethodInfo
data () => ExpanderSetLabelWidgetMethodInfo
data () => ExpanderSetResizeToplevelMethodInfo
data () => ExpanderSetSpacingMethodInfo
data () => ExpanderSetUseMarkupMethodInfo
data () => ExpanderSetUseUnderlineMethodInfo
data () => ExpanderSpacingPropertyInfo
data () => ExpanderUseMarkupPropertyInfo
data () => ExpanderUseUnderlinePropertyInfo
type family ResolveExpanderMethod (t :: Symbol) o
type family ResolveExpanderAccessibleMethod (t :: Symbol) o
data () => FileChooserButtonDialogPropertyInfo
data () => FileChooserButtonFileSetSignalInfo
data () => FileChooserButtonGetFocusOnClickMethodInfo
data () => FileChooserButtonGetTitleMethodInfo
data () => FileChooserButtonGetWidthCharsMethodInfo
data () => FileChooserButtonSetFocusOnClickMethodInfo
data () => FileChooserButtonSetTitleMethodInfo
data () => FileChooserButtonSetWidthCharsMethodInfo
data () => FileChooserButtonTitlePropertyInfo
data () => FileChooserButtonWidthCharsPropertyInfo
type family ResolveFileChooserButtonMethod (t :: Symbol) o
type family ResolveFileChooserDialogMethod (t :: Symbol) o
data () => FileChooserNativeAcceptLabelPropertyInfo
data () => FileChooserNativeCancelLabelPropertyInfo
data () => FileChooserNativeGetAcceptLabelMethodInfo
data () => FileChooserNativeGetCancelLabelMethodInfo
data () => FileChooserNativeSetAcceptLabelMethodInfo
data () => FileChooserNativeSetCancelLabelMethodInfo
type family ResolveFileChooserNativeMethod (t :: Symbol) o
data () => FileChooserWidgetDesktopFolderSignalInfo
data () => FileChooserWidgetDownFolderSignalInfo
data () => FileChooserWidgetHomeFolderSignalInfo
data () => FileChooserWidgetLocationPopupOnPasteSignalInfo
data () => FileChooserWidgetLocationPopupSignalInfo
data () => FileChooserWidgetLocationTogglePopupSignalInfo
data () => FileChooserWidgetPlacesShortcutSignalInfo
data () => FileChooserWidgetQuickBookmarkSignalInfo
data () => FileChooserWidgetRecentShortcutSignalInfo
data () => FileChooserWidgetSearchModePropertyInfo
data () => FileChooserWidgetSearchShortcutSignalInfo
data () => FileChooserWidgetShowHiddenSignalInfo
data () => FileChooserWidgetSubtitlePropertyInfo
data () => FileChooserWidgetUpFolderSignalInfo
type family ResolveFileChooserWidgetMethod (t :: Symbol) o
type family ResolveFileChooserWidgetAccessibleMethod (t :: Symbol) o
data () => FileFilterAddCustomMethodInfo
data () => FileFilterAddMimeTypeMethodInfo
data () => FileFilterAddPatternMethodInfo
data () => FileFilterAddPixbufFormatsMethodInfo
data () => FileFilterFilterMethodInfo
data () => FileFilterGetNameMethodInfo
data () => FileFilterGetNeededMethodInfo
data () => FileFilterSetNameMethodInfo
data () => FileFilterToGvariantMethodInfo
type family ResolveFileFilterMethod (t :: Symbol) o
data () => FixedMoveMethodInfo
data () => FixedPutMethodInfo
type family ResolveFixedMethod (t :: Symbol) o
data () => FlowBoxActivateCursorChildSignalInfo
data () => FlowBoxActivateOnSingleClickPropertyInfo
data () => FlowBoxBindModelMethodInfo
data () => FlowBoxChildActivatedSignalInfo
data () => FlowBoxColumnSpacingPropertyInfo
data () => FlowBoxGetActivateOnSingleClickMethodInfo
data () => FlowBoxGetChildAtIndexMethodInfo
data () => FlowBoxGetChildAtPosMethodInfo
data () => FlowBoxGetColumnSpacingMethodInfo
data () => FlowBoxGetHomogeneousMethodInfo
data () => FlowBoxGetMaxChildrenPerLineMethodInfo
data () => FlowBoxGetMinChildrenPerLineMethodInfo
data () => FlowBoxGetRowSpacingMethodInfo
data () => FlowBoxGetSelectedChildrenMethodInfo
data () => FlowBoxGetSelectionModeMethodInfo
data () => FlowBoxHomogeneousPropertyInfo
data () => FlowBoxInsertMethodInfo
data () => FlowBoxInvalidateFilterMethodInfo
data () => FlowBoxInvalidateSortMethodInfo
data () => FlowBoxMaxChildrenPerLinePropertyInfo
data () => FlowBoxMinChildrenPerLinePropertyInfo
data () => FlowBoxMoveCursorSignalInfo
data () => FlowBoxRowSpacingPropertyInfo
data () => FlowBoxSelectAllMethodInfo
data () => FlowBoxSelectAllSignalInfo
data () => FlowBoxSelectChildMethodInfo
data () => FlowBoxSelectedChildrenChangedSignalInfo
data () => FlowBoxSelectedForeachMethodInfo
data () => FlowBoxSelectionModePropertyInfo
data () => FlowBoxSetActivateOnSingleClickMethodInfo
data () => FlowBoxSetColumnSpacingMethodInfo
data () => FlowBoxSetFilterFuncMethodInfo
data () => FlowBoxSetHadjustmentMethodInfo
data () => FlowBoxSetHomogeneousMethodInfo
data () => FlowBoxSetMaxChildrenPerLineMethodInfo
data () => FlowBoxSetMinChildrenPerLineMethodInfo
data () => FlowBoxSetRowSpacingMethodInfo
data () => FlowBoxSetSelectionModeMethodInfo
data () => FlowBoxSetSortFuncMethodInfo
data () => FlowBoxSetVadjustmentMethodInfo
data () => FlowBoxToggleCursorChildSignalInfo
data () => FlowBoxUnselectAllMethodInfo
data () => FlowBoxUnselectAllSignalInfo
data () => FlowBoxUnselectChildMethodInfo
type family ResolveFlowBoxMethod (t :: Symbol) o
type family ResolveFlowBoxAccessibleMethod (t :: Symbol) o
data () => FlowBoxChildActivateSignalInfo
data () => FlowBoxChildChangedMethodInfo
data () => FlowBoxChildGetIndexMethodInfo
data () => FlowBoxChildIsSelectedMethodInfo
type family ResolveFlowBoxChildMethod (t :: Symbol) o
type family ResolveFlowBoxChildAccessibleMethod (t :: Symbol) o
data () => FontButtonFontNamePropertyInfo
data () => FontButtonFontSetSignalInfo
data () => FontButtonGetFontNameMethodInfo
data () => FontButtonGetShowSizeMethodInfo
data () => FontButtonGetShowStyleMethodInfo
data () => FontButtonGetTitleMethodInfo
data () => FontButtonGetUseFontMethodInfo
data () => FontButtonGetUseSizeMethodInfo
data () => FontButtonSetFontNameMethodInfo
data () => FontButtonSetShowSizeMethodInfo
data () => FontButtonSetShowStyleMethodInfo
data () => FontButtonSetTitleMethodInfo
data () => FontButtonSetUseFontMethodInfo
data () => FontButtonSetUseSizeMethodInfo
data () => FontButtonShowSizePropertyInfo
data () => FontButtonShowStylePropertyInfo
data () => FontButtonTitlePropertyInfo
data () => FontButtonUseFontPropertyInfo
data () => FontButtonUseSizePropertyInfo
type family ResolveFontButtonMethod (t :: Symbol) o
type family ResolveFontChooserDialogMethod (t :: Symbol) o
data () => FontChooserWidgetTweakActionPropertyInfo
type family ResolveFontChooserWidgetMethod (t :: Symbol) o
data () => FontSelectionFontNamePropertyInfo
data () => FontSelectionGetFaceListMethodInfo
data () => FontSelectionGetFaceMethodInfo
data () => FontSelectionGetFamilyListMethodInfo
data () => FontSelectionGetFamilyMethodInfo
data () => FontSelectionGetFontNameMethodInfo
data () => FontSelectionGetPreviewEntryMethodInfo
data () => FontSelectionGetPreviewTextMethodInfo
data () => FontSelectionGetSizeEntryMethodInfo
data () => FontSelectionGetSizeListMethodInfo
data () => FontSelectionGetSizeMethodInfo
data () => FontSelectionPreviewTextPropertyInfo
data () => FontSelectionSetFontNameMethodInfo
data () => FontSelectionSetPreviewTextMethodInfo
type family ResolveFontSelectionMethod (t :: Symbol) o
data () => FontSelectionDialogGetCancelButtonMethodInfo
data () => FontSelectionDialogGetFontNameMethodInfo
data () => FontSelectionDialogGetFontSelectionMethodInfo
data () => FontSelectionDialogGetOkButtonMethodInfo
data () => FontSelectionDialogGetPreviewTextMethodInfo
data () => FontSelectionDialogSetFontNameMethodInfo
data () => FontSelectionDialogSetPreviewTextMethodInfo
type family ResolveFontSelectionDialogMethod (t :: Symbol) o
data () => FrameGetLabelAlignMethodInfo
data () => FrameGetLabelMethodInfo
data () => FrameGetLabelWidgetMethodInfo
data () => FrameGetShadowTypeMethodInfo
data () => FrameLabelPropertyInfo
data () => FrameLabelWidgetPropertyInfo
data () => FrameLabelXalignPropertyInfo
data () => FrameLabelYalignPropertyInfo
data () => FrameSetLabelAlignMethodInfo
data () => FrameSetLabelMethodInfo
data () => FrameSetLabelWidgetMethodInfo
data () => FrameSetShadowTypeMethodInfo
data () => FrameShadowTypePropertyInfo
type family ResolveFrameMethod (t :: Symbol) o
type family ResolveFrameAccessibleMethod (t :: Symbol) o
data () => GLAreaAttachBuffersMethodInfo
data () => GLAreaAutoRenderPropertyInfo
data () => GLAreaContextPropertyInfo
data () => GLAreaCreateContextSignalInfo
data () => GLAreaGetAutoRenderMethodInfo
data () => GLAreaGetContextMethodInfo
data () => GLAreaGetErrorMethodInfo
data () => GLAreaGetHasAlphaMethodInfo
data () => GLAreaGetHasDepthBufferMethodInfo
data () => GLAreaGetHasStencilBufferMethodInfo
data () => GLAreaGetRequiredVersionMethodInfo
data () => GLAreaGetUseEsMethodInfo
data () => GLAreaHasAlphaPropertyInfo
data () => GLAreaHasDepthBufferPropertyInfo
data () => GLAreaHasStencilBufferPropertyInfo
data () => GLAreaMakeCurrentMethodInfo
data () => GLAreaQueueRenderMethodInfo
data () => GLAreaRenderSignalInfo
data () => GLAreaResizeSignalInfo
data () => GLAreaSetAutoRenderMethodInfo
data () => GLAreaSetErrorMethodInfo
data () => GLAreaSetHasAlphaMethodInfo
data () => GLAreaSetHasDepthBufferMethodInfo
data () => GLAreaSetHasStencilBufferMethodInfo
data () => GLAreaSetRequiredVersionMethodInfo
data () => GLAreaSetUseEsMethodInfo
data () => GLAreaUseEsPropertyInfo
type family ResolveGLAreaMethod (t :: Symbol) o
data () => GestureBeginSignalInfo
data () => GestureCancelSignalInfo
data () => GestureEndSignalInfo
data () => GestureGetBoundingBoxCenterMethodInfo
data () => GestureGetBoundingBoxMethodInfo
data () => GestureGetDeviceMethodInfo
data () => GestureGetGroupMethodInfo
data () => GestureGetLastEventMethodInfo
data () => GestureGetLastUpdatedSequenceMethodInfo
data () => GestureGetPointMethodInfo
data () => GestureGetSequenceStateMethodInfo
data () => GestureGetSequencesMethodInfo
data () => GestureGetWindowMethodInfo
data () => GestureGroupMethodInfo
data () => GestureHandlesSequenceMethodInfo
data () => GestureIsActiveMethodInfo
data () => GestureIsGroupedWithMethodInfo
data () => GestureIsRecognizedMethodInfo
data () => GestureNPointsPropertyInfo
data () => GestureSequenceStateChangedSignalInfo
data () => GestureSetSequenceStateMethodInfo
data () => GestureSetStateMethodInfo
data () => GestureSetWindowMethodInfo
data () => GestureUngroupMethodInfo
data () => GestureUpdateSignalInfo
data () => GestureWindowPropertyInfo
type family ResolveGestureMethod (t :: Symbol) o
data () => GestureDragDragBeginSignalInfo
data () => GestureDragDragEndSignalInfo
data () => GestureDragDragUpdateSignalInfo
data () => GestureDragGetOffsetMethodInfo
data () => GestureDragGetStartPointMethodInfo
type family ResolveGestureDragMethod (t :: Symbol) o
data () => GestureLongPressCancelledSignalInfo
data () => GestureLongPressDelayFactorPropertyInfo
data () => GestureLongPressPressedSignalInfo
type family ResolveGestureLongPressMethod (t :: Symbol) o
data () => GestureMultiPressGetAreaMethodInfo
data () => GestureMultiPressPressedSignalInfo
data () => GestureMultiPressReleasedSignalInfo
data () => GestureMultiPressSetAreaMethodInfo
data () => GestureMultiPressStoppedSignalInfo
type family ResolveGestureMultiPressMethod (t :: Symbol) o
data () => GesturePanGetOrientationMethodInfo
data () => GesturePanOrientationPropertyInfo
data () => GesturePanPanSignalInfo
data () => GesturePanSetOrientationMethodInfo
type family ResolveGesturePanMethod (t :: Symbol) o
data () => GestureRotateAngleChangedSignalInfo
data () => GestureRotateGetAngleDeltaMethodInfo
type family ResolveGestureRotateMethod (t :: Symbol) o
data () => GestureSingleButtonPropertyInfo
data () => GestureSingleExclusivePropertyInfo
data () => GestureSingleGetButtonMethodInfo
data () => GestureSingleGetCurrentButtonMethodInfo
data () => GestureSingleGetCurrentSequenceMethodInfo
data () => GestureSingleGetExclusiveMethodInfo
data () => GestureSingleGetTouchOnlyMethodInfo
data () => GestureSingleSetButtonMethodInfo
data () => GestureSingleSetExclusiveMethodInfo
data () => GestureSingleSetTouchOnlyMethodInfo
data () => GestureSingleTouchOnlyPropertyInfo
type family ResolveGestureSingleMethod (t :: Symbol) o
data () => GestureStylusDownSignalInfo
data () => GestureStylusGetAxesMethodInfo
data () => GestureStylusGetAxisMethodInfo
data () => GestureStylusGetDeviceToolMethodInfo
data () => GestureStylusMotionSignalInfo
data () => GestureStylusProximitySignalInfo
data () => GestureStylusUpSignalInfo
type family ResolveGestureStylusMethod (t :: Symbol) o
data () => GestureSwipeGetVelocityMethodInfo
data () => GestureSwipeSwipeSignalInfo
type family ResolveGestureSwipeMethod (t :: Symbol) o
data () => GestureZoomGetScaleDeltaMethodInfo
data () => GestureZoomScaleChangedSignalInfo
type family ResolveGestureZoomMethod (t :: Symbol) o
data () => GridAttachMethodInfo
data () => GridAttachNextToMethodInfo
data () => GridBaselineRowPropertyInfo
data () => GridColumnHomogeneousPropertyInfo
data () => GridColumnSpacingPropertyInfo
data () => GridGetBaselineRowMethodInfo
data () => GridGetChildAtMethodInfo
data () => GridGetColumnHomogeneousMethodInfo
data () => GridGetColumnSpacingMethodInfo
data () => GridGetRowBaselinePositionMethodInfo
data () => GridGetRowHomogeneousMethodInfo
data () => GridGetRowSpacingMethodInfo
data () => GridInsertColumnMethodInfo
data () => GridInsertNextToMethodInfo
data () => GridInsertRowMethodInfo
data () => GridRemoveColumnMethodInfo
data () => GridRemoveRowMethodInfo
data () => GridRowHomogeneousPropertyInfo
data () => GridRowSpacingPropertyInfo
data () => GridSetBaselineRowMethodInfo
data () => GridSetColumnHomogeneousMethodInfo
data () => GridSetColumnSpacingMethodInfo
data () => GridSetRowBaselinePositionMethodInfo
data () => GridSetRowHomogeneousMethodInfo
data () => GridSetRowSpacingMethodInfo
type family ResolveGridMethod (t :: Symbol) o
type family ResolveHBoxMethod (t :: Symbol) o
type family ResolveHButtonBoxMethod (t :: Symbol) o
type family ResolveHPanedMethod (t :: Symbol) o
data () => HSVChangedSignalInfo
data () => HSVGetColorMethodInfo
data () => HSVGetMetricsMethodInfo
data () => HSVIsAdjustingMethodInfo
data () => HSVMoveSignalInfo
data () => HSVSetColorMethodInfo
data () => HSVSetMetricsMethodInfo
type family ResolveHSVMethod (t :: Symbol) o
type family ResolveHScaleMethod (t :: Symbol) o
type family ResolveHScrollbarMethod (t :: Symbol) o
type family ResolveHSeparatorMethod (t :: Symbol) o
data () => HandleBoxChildAttachedSignalInfo
data () => HandleBoxChildDetachedPropertyInfo
data () => HandleBoxChildDetachedSignalInfo
data () => HandleBoxGetChildDetachedMethodInfo
data () => HandleBoxGetHandlePositionMethodInfo
data () => HandleBoxGetShadowTypeMethodInfo
data () => HandleBoxGetSnapEdgeMethodInfo
data () => HandleBoxHandlePositionPropertyInfo
data () => HandleBoxSetHandlePositionMethodInfo
data () => HandleBoxSetShadowTypeMethodInfo
data () => HandleBoxSetSnapEdgeMethodInfo
data () => HandleBoxShadowTypePropertyInfo
data () => HandleBoxSnapEdgePropertyInfo
data () => HandleBoxSnapEdgeSetPropertyInfo
type family ResolveHandleBoxMethod (t :: Symbol) o
data () => HeaderBarCustomTitlePropertyInfo
data () => HeaderBarDecorationLayoutPropertyInfo
data () => HeaderBarDecorationLayoutSetPropertyInfo
data () => HeaderBarGetCustomTitleMethodInfo
data () => HeaderBarGetDecorationLayoutMethodInfo
data () => HeaderBarGetHasSubtitleMethodInfo
data () => HeaderBarGetShowCloseButtonMethodInfo
data () => HeaderBarGetSubtitleMethodInfo
data () => HeaderBarGetTitleMethodInfo
data () => HeaderBarHasSubtitlePropertyInfo
data () => HeaderBarPackEndMethodInfo
data () => HeaderBarPackStartMethodInfo
data () => HeaderBarSetCustomTitleMethodInfo
data () => HeaderBarSetDecorationLayoutMethodInfo
data () => HeaderBarSetHasSubtitleMethodInfo
data () => HeaderBarSetShowCloseButtonMethodInfo
data () => HeaderBarSetSubtitleMethodInfo
data () => HeaderBarSetTitleMethodInfo
data () => HeaderBarShowCloseButtonPropertyInfo
data () => HeaderBarSpacingPropertyInfo
data () => HeaderBarSubtitlePropertyInfo
data () => HeaderBarTitlePropertyInfo
type family ResolveHeaderBarMethod (t :: Symbol) o
type family ResolveHeaderBarAccessibleMethod (t :: Symbol) o
data () => IMContextCommitSignalInfo
data () => IMContextDeleteSurroundingMethodInfo
data () => IMContextDeleteSurroundingSignalInfo
data () => IMContextFilterKeypressMethodInfo
data () => IMContextFocusInMethodInfo
data () => IMContextFocusOutMethodInfo
data () => IMContextGetPreeditStringMethodInfo
data () => IMContextGetSurroundingMethodInfo
data () => IMContextInputHintsPropertyInfo
data () => IMContextInputPurposePropertyInfo
data () => IMContextPreeditChangedSignalInfo
data () => IMContextPreeditEndSignalInfo
data () => IMContextPreeditStartSignalInfo
data () => IMContextResetMethodInfo
data () => IMContextRetrieveSurroundingSignalInfo
data () => IMContextSetClientWindowMethodInfo
data () => IMContextSetCursorLocationMethodInfo
data () => IMContextSetSurroundingMethodInfo
data () => IMContextSetUsePreeditMethodInfo
type family ResolveIMContextMethod (t :: Symbol) o
data () => IMContextSimpleAddComposeFileMethodInfo
type family ResolveIMContextSimpleMethod (t :: Symbol) o
data () => IMMulticontextAppendMenuitemsMethodInfo
data () => IMMulticontextGetContextIdMethodInfo
data () => IMMulticontextSetContextIdMethodInfo
type family ResolveIMMulticontextMethod (t :: Symbol) o
data () => IconFactoryAddDefaultMethodInfo
data () => IconFactoryAddMethodInfo
data () => IconFactoryLookupMethodInfo
data () => IconFactoryRemoveDefaultMethodInfo
type family ResolveIconFactoryMethod (t :: Symbol) o
data () => IconInfoGetAttachPointsMethodInfo
data () => IconInfoGetBaseScaleMethodInfo
data () => IconInfoGetBaseSizeMethodInfo
data () => IconInfoGetBuiltinPixbufMethodInfo
data () => IconInfoGetDisplayNameMethodInfo
data () => IconInfoGetEmbeddedRectMethodInfo
data () => IconInfoGetFilenameMethodInfo
data () => IconInfoIsSymbolicMethodInfo
data () => IconInfoLoadIconAsyncMethodInfo
data () => IconInfoLoadIconFinishMethodInfo
data () => IconInfoLoadIconMethodInfo
data () => IconInfoLoadSurfaceMethodInfo
data () => IconInfoLoadSymbolicAsyncMethodInfo
data () => IconInfoLoadSymbolicFinishMethodInfo
data () => IconInfoLoadSymbolicForContextAsyncMethodInfo
data () => IconInfoLoadSymbolicForContextFinishMethodInfo
data () => IconInfoLoadSymbolicForContextMethodInfo
data () => IconInfoLoadSymbolicForStyleMethodInfo
data () => IconInfoLoadSymbolicMethodInfo
data () => IconInfoSetRawCoordinatesMethodInfo
type family ResolveIconInfoMethod (t :: Symbol) o
data () => IconThemeAddResourcePathMethodInfo
data () => IconThemeAppendSearchPathMethodInfo
data () => IconThemeChangedSignalInfo
data () => IconThemeChooseIconForScaleMethodInfo
data () => IconThemeChooseIconMethodInfo
data () => IconThemeGetExampleIconNameMethodInfo
data () => IconThemeGetIconSizesMethodInfo
data () => IconThemeGetSearchPathMethodInfo
data () => IconThemeHasIconMethodInfo
data () => IconThemeListContextsMethodInfo
data () => IconThemeListIconsMethodInfo
data () => IconThemeLoadIconForScaleMethodInfo
data () => IconThemeLoadIconMethodInfo
data () => IconThemeLoadSurfaceMethodInfo
data () => IconThemeLookupByGiconForScaleMethodInfo
data () => IconThemeLookupByGiconMethodInfo
data () => IconThemeLookupIconForScaleMethodInfo
data () => IconThemeLookupIconMethodInfo
data () => IconThemePrependSearchPathMethodInfo
data () => IconThemeRescanIfNeededMethodInfo
data () => IconThemeSetCustomThemeMethodInfo
data () => IconThemeSetScreenMethodInfo
data () => IconThemeSetSearchPathMethodInfo
type family ResolveIconThemeMethod (t :: Symbol) o
data () => IconViewActivateCursorItemSignalInfo
data () => IconViewActivateOnSingleClickPropertyInfo
data () => IconViewCellAreaPropertyInfo
data () => IconViewColumnSpacingPropertyInfo
data () => IconViewColumnsPropertyInfo
data () => IconViewConvertWidgetToBinWindowCoordsMethodInfo
data () => IconViewCreateDragIconMethodInfo
data () => IconViewEnableModelDragDestMethodInfo
data () => IconViewEnableModelDragSourceMethodInfo
data () => IconViewGetActivateOnSingleClickMethodInfo
data () => IconViewGetCellRectMethodInfo
data () => IconViewGetColumnSpacingMethodInfo
data () => IconViewGetColumnsMethodInfo
data () => IconViewGetCursorMethodInfo
data () => IconViewGetDestItemAtPosMethodInfo
data () => IconViewGetDragDestItemMethodInfo
data () => IconViewGetItemAtPosMethodInfo
data () => IconViewGetItemColumnMethodInfo
data () => IconViewGetItemOrientationMethodInfo
data () => IconViewGetItemPaddingMethodInfo
data () => IconViewGetItemRowMethodInfo
data () => IconViewGetItemWidthMethodInfo
data () => IconViewGetMarginMethodInfo
data () => IconViewGetMarkupColumnMethodInfo
data () => IconViewGetModelMethodInfo
data () => IconViewGetPathAtPosMethodInfo
data () => IconViewGetPixbufColumnMethodInfo
data () => IconViewGetReorderableMethodInfo
data () => IconViewGetRowSpacingMethodInfo
data () => IconViewGetSelectedItemsMethodInfo
data () => IconViewGetSelectionModeMethodInfo
data () => IconViewGetSpacingMethodInfo
data () => IconViewGetTextColumnMethodInfo
data () => IconViewGetTooltipColumnMethodInfo
data () => IconViewGetTooltipContextMethodInfo
data () => IconViewGetVisibleRangeMethodInfo
data () => IconViewItemActivatedMethodInfo
data () => IconViewItemActivatedSignalInfo
data () => IconViewItemOrientationPropertyInfo
data () => IconViewItemPaddingPropertyInfo
data () => IconViewItemWidthPropertyInfo
data () => IconViewMarginPropertyInfo
data () => IconViewMarkupColumnPropertyInfo
data () => IconViewModelPropertyInfo
data () => IconViewMoveCursorSignalInfo
data () => IconViewPathIsSelectedMethodInfo
data () => IconViewPixbufColumnPropertyInfo
data () => IconViewReorderablePropertyInfo
data () => IconViewRowSpacingPropertyInfo
data () => IconViewScrollToPathMethodInfo
data () => IconViewSelectAllMethodInfo
data () => IconViewSelectAllSignalInfo
data () => IconViewSelectCursorItemSignalInfo
data () => IconViewSelectPathMethodInfo
data () => IconViewSelectedForeachMethodInfo
data () => IconViewSelectionChangedSignalInfo
data () => IconViewSelectionModePropertyInfo
data () => IconViewSetActivateOnSingleClickMethodInfo
data () => IconViewSetColumnSpacingMethodInfo
data () => IconViewSetColumnsMethodInfo
data () => IconViewSetCursorMethodInfo
data () => IconViewSetDragDestItemMethodInfo
data () => IconViewSetItemOrientationMethodInfo
data () => IconViewSetItemPaddingMethodInfo
data () => IconViewSetItemWidthMethodInfo
data () => IconViewSetMarginMethodInfo
data () => IconViewSetMarkupColumnMethodInfo
data () => IconViewSetModelMethodInfo
data () => IconViewSetPixbufColumnMethodInfo
data () => IconViewSetReorderableMethodInfo
data () => IconViewSetRowSpacingMethodInfo
data () => IconViewSetSelectionModeMethodInfo
data () => IconViewSetSpacingMethodInfo
data () => IconViewSetTextColumnMethodInfo
data () => IconViewSetTooltipCellMethodInfo
data () => IconViewSetTooltipColumnMethodInfo
data () => IconViewSetTooltipItemMethodInfo
data () => IconViewSpacingPropertyInfo
data () => IconViewTextColumnPropertyInfo
data () => IconViewToggleCursorItemSignalInfo
data () => IconViewTooltipColumnPropertyInfo
data () => IconViewUnselectAllMethodInfo
data () => IconViewUnselectAllSignalInfo
data () => IconViewUnselectPathMethodInfo
data () => IconViewUnsetModelDragDestMethodInfo
data () => IconViewUnsetModelDragSourceMethodInfo
type family ResolveIconViewMethod (t :: Symbol) o
type family ResolveIconViewAccessibleMethod (t :: Symbol) o
data () => ImageClearMethodInfo
data () => ImageFilePropertyInfo
data () => ImageGetAnimationMethodInfo
data () => ImageGetGiconMethodInfo
data () => ImageGetIconNameMethodInfo
data () => ImageGetIconSetMethodInfo
data () => ImageGetPixbufMethodInfo
data () => ImageGetPixelSizeMethodInfo
data () => ImageGetStockMethodInfo
data () => ImageGetStorageTypeMethodInfo
data () => ImageGiconPropertyInfo
data () => ImageIconNamePropertyInfo
data () => ImageIconSetPropertyInfo
data () => ImageIconSizePropertyInfo
data () => ImagePixbufAnimationPropertyInfo
data () => ImagePixbufPropertyInfo
data () => ImagePixelSizePropertyInfo
data () => ImageResourcePropertyInfo
data () => ImageSetFromAnimationMethodInfo
data () => ImageSetFromFileMethodInfo
data () => ImageSetFromGiconMethodInfo
data () => ImageSetFromIconNameMethodInfo
data () => ImageSetFromIconSetMethodInfo
data () => ImageSetFromPixbufMethodInfo
data () => ImageSetFromResourceMethodInfo
data () => ImageSetFromStockMethodInfo
data () => ImageSetFromSurfaceMethodInfo
data () => ImageSetPixelSizeMethodInfo
data () => ImageStockPropertyInfo
data () => ImageStorageTypePropertyInfo
data () => ImageSurfacePropertyInfo
data () => ImageUseFallbackPropertyInfo
type family ResolveImageMethod (t :: Symbol) o
type family ResolveImageAccessibleMethod (t :: Symbol) o
type family ResolveImageCellAccessibleMethod (t :: Symbol) o
data () => ImageMenuItemAccelGroupPropertyInfo
data () => ImageMenuItemAlwaysShowImagePropertyInfo
data () => ImageMenuItemGetAlwaysShowImageMethodInfo
data () => ImageMenuItemGetImageMethodInfo
data () => ImageMenuItemGetUseStockMethodInfo
data () => ImageMenuItemImagePropertyInfo
data () => ImageMenuItemSetAccelGroupMethodInfo
data () => ImageMenuItemSetAlwaysShowImageMethodInfo
data () => ImageMenuItemSetImageMethodInfo
data () => ImageMenuItemSetUseStockMethodInfo
data () => ImageMenuItemUseStockPropertyInfo
type family ResolveImageMenuItemMethod (t :: Symbol) o
data () => InfoBarAddActionWidgetMethodInfo
data () => InfoBarAddButtonMethodInfo
data () => InfoBarCloseSignalInfo
data () => InfoBarGetActionAreaMethodInfo
data () => InfoBarGetContentAreaMethodInfo
data () => InfoBarGetMessageTypeMethodInfo
data () => InfoBarGetRevealedMethodInfo
data () => InfoBarGetShowCloseButtonMethodInfo
data () => InfoBarMessageTypePropertyInfo
data () => InfoBarResponseMethodInfo
data () => InfoBarResponseSignalInfo
data () => InfoBarRevealedPropertyInfo
data () => InfoBarSetDefaultResponseMethodInfo
data () => InfoBarSetMessageTypeMethodInfo
data () => InfoBarSetResponseSensitiveMethodInfo
data () => InfoBarSetRevealedMethodInfo
data () => InfoBarSetShowCloseButtonMethodInfo
data () => InfoBarShowCloseButtonPropertyInfo
type family ResolveInfoBarMethod (t :: Symbol) o
data () => InvisibleGetScreenMethodInfo
data () => InvisibleScreenPropertyInfo
data () => InvisibleSetScreenMethodInfo
type family ResolveInvisibleMethod (t :: Symbol) o
data () => LabelActivateCurrentLinkSignalInfo
data () => LabelActivateLinkSignalInfo
data () => LabelAnglePropertyInfo
data () => LabelAttributesPropertyInfo
data () => LabelCopyClipboardSignalInfo
data () => LabelCursorPositionPropertyInfo
data () => LabelEllipsizePropertyInfo
data () => LabelGetAngleMethodInfo
data () => LabelGetAttributesMethodInfo
data () => LabelGetCurrentUriMethodInfo
data () => LabelGetEllipsizeMethodInfo
data () => LabelGetJustifyMethodInfo
data () => LabelGetLabelMethodInfo
data () => LabelGetLayoutMethodInfo
data () => LabelGetLayoutOffsetsMethodInfo
data () => LabelGetLineWrapMethodInfo
data () => LabelGetLineWrapModeMethodInfo
data () => LabelGetLinesMethodInfo
data () => LabelGetMaxWidthCharsMethodInfo
data () => LabelGetMnemonicKeyvalMethodInfo
data () => LabelGetMnemonicWidgetMethodInfo
data () => LabelGetSelectableMethodInfo
data () => LabelGetSelectionBoundsMethodInfo
data () => LabelGetSingleLineModeMethodInfo
data () => LabelGetTextMethodInfo
data () => LabelGetTrackVisitedLinksMethodInfo
data () => LabelGetUseMarkupMethodInfo
data () => LabelGetUseUnderlineMethodInfo
data () => LabelGetWidthCharsMethodInfo
data () => LabelGetXalignMethodInfo
data () => LabelGetYalignMethodInfo
data () => LabelJustifyPropertyInfo
data () => LabelLabelPropertyInfo
data () => LabelLinesPropertyInfo
data () => LabelMaxWidthCharsPropertyInfo
data () => LabelMnemonicKeyvalPropertyInfo
data () => LabelMnemonicWidgetPropertyInfo
data () => LabelMoveCursorSignalInfo
data () => LabelPatternPropertyInfo
data () => LabelPopulatePopupSignalInfo
data () => LabelSelectRegionMethodInfo
data () => LabelSelectablePropertyInfo
data () => LabelSelectionBoundPropertyInfo
data () => LabelSetAngleMethodInfo
data () => LabelSetAttributesMethodInfo
data () => LabelSetEllipsizeMethodInfo
data () => LabelSetJustifyMethodInfo
data () => LabelSetLabelMethodInfo
data () => LabelSetLineWrapMethodInfo
data () => LabelSetLineWrapModeMethodInfo
data () => LabelSetLinesMethodInfo
data () => LabelSetMarkupMethodInfo
data () => LabelSetMarkupWithMnemonicMethodInfo
data () => LabelSetMaxWidthCharsMethodInfo
data () => LabelSetMnemonicWidgetMethodInfo
data () => LabelSetPatternMethodInfo
data () => LabelSetSelectableMethodInfo
data () => LabelSetSingleLineModeMethodInfo
data () => LabelSetTextMethodInfo
data () => LabelSetTextWithMnemonicMethodInfo
data () => LabelSetTrackVisitedLinksMethodInfo
data () => LabelSetUseMarkupMethodInfo
data () => LabelSetUseUnderlineMethodInfo
data () => LabelSetWidthCharsMethodInfo
data () => LabelSetXalignMethodInfo
data () => LabelSetYalignMethodInfo
data () => LabelSingleLineModePropertyInfo
data () => LabelTrackVisitedLinksPropertyInfo
data () => LabelUseMarkupPropertyInfo
data () => LabelUseUnderlinePropertyInfo
data () => LabelWidthCharsPropertyInfo
data () => LabelWrapModePropertyInfo
data () => LabelWrapPropertyInfo
data () => LabelXalignPropertyInfo
data () => LabelYalignPropertyInfo
type family ResolveLabelMethod (t :: Symbol) o
type family ResolveLabelAccessibleMethod (t :: Symbol) o
data () => LayoutGetBinWindowMethodInfo
data () => LayoutGetHadjustmentMethodInfo
data () => LayoutGetSizeMethodInfo
data () => LayoutGetVadjustmentMethodInfo
data () => LayoutHeightPropertyInfo
data () => LayoutMoveMethodInfo
data () => LayoutPutMethodInfo
data () => LayoutSetHadjustmentMethodInfo
data () => LayoutSetSizeMethodInfo
data () => LayoutSetVadjustmentMethodInfo
data () => LayoutWidthPropertyInfo
type family ResolveLayoutMethod (t :: Symbol) o
data () => LevelBarAddOffsetValueMethodInfo
data () => LevelBarGetInvertedMethodInfo
data () => LevelBarGetMaxValueMethodInfo
data () => LevelBarGetMinValueMethodInfo
data () => LevelBarGetModeMethodInfo
data () => LevelBarGetOffsetValueMethodInfo
data () => LevelBarGetValueMethodInfo
data () => LevelBarInvertedPropertyInfo
data () => LevelBarMaxValuePropertyInfo
data () => LevelBarMinValuePropertyInfo
data () => LevelBarModePropertyInfo
data () => LevelBarOffsetChangedSignalInfo
data () => LevelBarRemoveOffsetValueMethodInfo
data () => LevelBarSetInvertedMethodInfo
data () => LevelBarSetMaxValueMethodInfo
data () => LevelBarSetMinValueMethodInfo
data () => LevelBarSetModeMethodInfo
data () => LevelBarSetValueMethodInfo
data () => LevelBarValuePropertyInfo
type family ResolveLevelBarMethod (t :: Symbol) o
type family ResolveLevelBarAccessibleMethod (t :: Symbol) o
data () => LinkButtonActivateLinkSignalInfo
data () => LinkButtonGetUriMethodInfo
data () => LinkButtonGetVisitedMethodInfo
data () => LinkButtonSetUriMethodInfo
data () => LinkButtonSetVisitedMethodInfo
data () => LinkButtonUriPropertyInfo
data () => LinkButtonVisitedPropertyInfo
type family ResolveLinkButtonMethod (t :: Symbol) o
type family ResolveLinkButtonAccessibleMethod (t :: Symbol) o
data () => ListBoxActivateCursorRowSignalInfo
data () => ListBoxActivateOnSingleClickPropertyInfo
data () => ListBoxBindModelMethodInfo
data () => ListBoxDragHighlightRowMethodInfo
data () => ListBoxDragUnhighlightRowMethodInfo
data () => ListBoxGetActivateOnSingleClickMethodInfo
data () => ListBoxGetAdjustmentMethodInfo
data () => ListBoxGetRowAtIndexMethodInfo
data () => ListBoxGetRowAtYMethodInfo
data () => ListBoxGetSelectedRowMethodInfo
data () => ListBoxGetSelectedRowsMethodInfo
data () => ListBoxGetSelectionModeMethodInfo
data () => ListBoxInsertMethodInfo
data () => ListBoxInvalidateFilterMethodInfo
data () => ListBoxInvalidateHeadersMethodInfo
data () => ListBoxInvalidateSortMethodInfo
data () => ListBoxMoveCursorSignalInfo
data () => ListBoxPrependMethodInfo
data () => ListBoxRowActivatedSignalInfo
data () => ListBoxRowSelectedSignalInfo
data () => ListBoxSelectAllMethodInfo
data () => ListBoxSelectAllSignalInfo
data () => ListBoxSelectRowMethodInfo
data () => ListBoxSelectedForeachMethodInfo
data () => ListBoxSelectedRowsChangedSignalInfo
data () => ListBoxSelectionModePropertyInfo
data () => ListBoxSetActivateOnSingleClickMethodInfo
data () => ListBoxSetAdjustmentMethodInfo
data () => ListBoxSetFilterFuncMethodInfo
data () => ListBoxSetHeaderFuncMethodInfo
data () => ListBoxSetPlaceholderMethodInfo
data () => ListBoxSetSelectionModeMethodInfo
data () => ListBoxSetSortFuncMethodInfo
data () => ListBoxToggleCursorRowSignalInfo
data () => ListBoxUnselectAllMethodInfo
data () => ListBoxUnselectAllSignalInfo
data () => ListBoxUnselectRowMethodInfo
type family ResolveListBoxMethod (t :: Symbol) o
type family ResolveListBoxAccessibleMethod (t :: Symbol) o
data () => ListBoxRowActivatablePropertyInfo
data () => ListBoxRowActivateSignalInfo
data () => ListBoxRowChangedMethodInfo
data () => ListBoxRowGetActivatableMethodInfo
data () => ListBoxRowGetHeaderMethodInfo
data () => ListBoxRowGetIndexMethodInfo
data () => ListBoxRowGetSelectableMethodInfo
data () => ListBoxRowIsSelectedMethodInfo
data () => ListBoxRowSelectablePropertyInfo
data () => ListBoxRowSetActivatableMethodInfo
data () => ListBoxRowSetHeaderMethodInfo
data () => ListBoxRowSetSelectableMethodInfo
type family ResolveListBoxRowMethod (t :: Symbol) o
type family ResolveListBoxRowAccessibleMethod (t :: Symbol) o
data () => ListStoreAppendMethodInfo
data () => ListStoreClearMethodInfo
data () => ListStoreInsertAfterMethodInfo
data () => ListStoreInsertBeforeMethodInfo
data () => ListStoreInsertMethodInfo
data () => ListStoreInsertWithValuesvMethodInfo
data () => ListStoreIterIsValidMethodInfo
data () => ListStoreMoveAfterMethodInfo
data () => ListStoreMoveBeforeMethodInfo
data () => ListStorePrependMethodInfo
data () => ListStoreRemoveMethodInfo
data () => ListStoreReorderMethodInfo
data () => ListStoreSetColumnTypesMethodInfo
data () => ListStoreSetMethodInfo
data () => ListStoreSetValueMethodInfo
data () => ListStoreSwapMethodInfo
type family ResolveListStoreMethod (t :: Symbol) o
data () => LockButtonGetPermissionMethodInfo
data () => LockButtonPermissionPropertyInfo
data () => LockButtonSetPermissionMethodInfo
data () => LockButtonTextLockPropertyInfo
data () => LockButtonTextUnlockPropertyInfo
data () => LockButtonTooltipLockPropertyInfo
data () => LockButtonTooltipNotAuthorizedPropertyInfo
data () => LockButtonTooltipUnlockPropertyInfo
type family ResolveLockButtonMethod (t :: Symbol) o
type family ResolveLockButtonAccessibleMethod (t :: Symbol) o
data () => MenuAccelGroupPropertyInfo
data () => MenuAccelPathPropertyInfo
data () => MenuActivePropertyInfo
data () => MenuAnchorHintsPropertyInfo
data () => MenuAttachMethodInfo
data () => MenuAttachToWidgetMethodInfo
data () => MenuAttachWidgetPropertyInfo
data () => MenuDetachMethodInfo
data () => MenuGetAccelGroupMethodInfo
data () => MenuGetAccelPathMethodInfo
data () => MenuGetActiveMethodInfo
data () => MenuGetAttachWidgetMethodInfo
data () => MenuGetMonitorMethodInfo
data () => MenuGetReserveToggleSizeMethodInfo
data () => MenuGetTearoffStateMethodInfo
data () => MenuGetTitleMethodInfo
data () => MenuMenuTypeHintPropertyInfo
data () => MenuMonitorPropertyInfo
data () => MenuMoveScrollSignalInfo
data () => MenuPlaceOnMonitorMethodInfo
data () => MenuPopdownMethodInfo
data () => MenuPoppedUpSignalInfo
data () => MenuPopupAtPointerMethodInfo
data () => MenuPopupAtRectMethodInfo
data () => MenuPopupAtWidgetMethodInfo
data () => MenuPopupForDeviceMethodInfo
data () => MenuPopupMethodInfo
data () => MenuRectAnchorDxPropertyInfo
data () => MenuRectAnchorDyPropertyInfo
data () => MenuReorderChildMethodInfo
data () => MenuRepositionMethodInfo
data () => MenuReserveToggleSizePropertyInfo
data () => MenuSetAccelGroupMethodInfo
data () => MenuSetAccelPathMethodInfo
data () => MenuSetActiveMethodInfo
data () => MenuSetMonitorMethodInfo
data () => MenuSetReserveToggleSizeMethodInfo
data () => MenuSetScreenMethodInfo
data () => MenuSetTearoffStateMethodInfo
data () => MenuSetTitleMethodInfo
data () => MenuTearoffStatePropertyInfo
data () => MenuTearoffTitlePropertyInfo
type family ResolveMenuMethod (t :: Symbol) o
type family ResolveMenuAccessibleMethod (t :: Symbol) o
data () => MenuBarChildPackDirectionPropertyInfo
data () => MenuBarGetChildPackDirectionMethodInfo
data () => MenuBarGetPackDirectionMethodInfo
data () => MenuBarPackDirectionPropertyInfo
data () => MenuBarSetChildPackDirectionMethodInfo
data () => MenuBarSetPackDirectionMethodInfo
type family ResolveMenuBarMethod (t :: Symbol) o
data () => MenuButtonAlignWidgetPropertyInfo
data () => MenuButtonDirectionPropertyInfo
data () => MenuButtonGetAlignWidgetMethodInfo
data () => MenuButtonGetDirectionMethodInfo
data () => MenuButtonGetMenuModelMethodInfo
data () => MenuButtonGetPopoverMethodInfo
data () => MenuButtonGetPopupMethodInfo
data () => MenuButtonGetUsePopoverMethodInfo
data () => MenuButtonMenuModelPropertyInfo
data () => MenuButtonPopoverPropertyInfo
data () => MenuButtonPopupPropertyInfo
data () => MenuButtonSetAlignWidgetMethodInfo
data () => MenuButtonSetDirectionMethodInfo
data () => MenuButtonSetMenuModelMethodInfo
data () => MenuButtonSetPopoverMethodInfo
data () => MenuButtonSetPopupMethodInfo
data () => MenuButtonSetUsePopoverMethodInfo
data () => MenuButtonUsePopoverPropertyInfo
type family ResolveMenuButtonMethod (t :: Symbol) o
type family ResolveMenuButtonAccessibleMethod (t :: Symbol) o
data () => MenuItemAccelPathPropertyInfo
data () => MenuItemActivateItemSignalInfo
data () => MenuItemActivateMethodInfo
data () => MenuItemActivateSignalInfo
data () => MenuItemDeselectMethodInfo
data () => MenuItemDeselectSignalInfo
data () => MenuItemGetAccelPathMethodInfo
data () => MenuItemGetLabelMethodInfo
data () => MenuItemGetReserveIndicatorMethodInfo
data () => MenuItemGetRightJustifiedMethodInfo
data () => MenuItemGetSubmenuMethodInfo
data () => MenuItemGetUseUnderlineMethodInfo
data () => MenuItemLabelPropertyInfo
data () => MenuItemRightJustifiedPropertyInfo
data () => MenuItemSelectMethodInfo
data () => MenuItemSelectSignalInfo
data () => MenuItemSetAccelPathMethodInfo
data () => MenuItemSetLabelMethodInfo
data () => MenuItemSetReserveIndicatorMethodInfo
data () => MenuItemSetRightJustifiedMethodInfo
data () => MenuItemSetSubmenuMethodInfo
data () => MenuItemSetUseUnderlineMethodInfo
data () => MenuItemSubmenuPropertyInfo
data () => MenuItemToggleSizeAllocateMethodInfo
data () => MenuItemToggleSizeAllocateSignalInfo
data () => MenuItemToggleSizeRequestMethodInfo
data () => MenuItemToggleSizeRequestSignalInfo
data () => MenuItemUseUnderlinePropertyInfo
type family ResolveMenuItemMethod (t :: Symbol) o
type family ResolveMenuItemAccessibleMethod (t :: Symbol) o
data () => MenuShellActivateCurrentSignalInfo
data () => MenuShellActivateItemMethodInfo
data () => MenuShellAppendMethodInfo
data () => MenuShellBindModelMethodInfo
data () => MenuShellCancelMethodInfo
data () => MenuShellCancelSignalInfo
data () => MenuShellCycleFocusSignalInfo
data () => MenuShellDeactivateMethodInfo
data () => MenuShellDeactivateSignalInfo
data () => MenuShellDeselectMethodInfo
data () => MenuShellGetParentShellMethodInfo
data () => MenuShellGetSelectedItemMethodInfo
data () => MenuShellGetTakeFocusMethodInfo
data () => MenuShellInsertMethodInfo
data () => MenuShellInsertSignalInfo
data () => MenuShellMoveCurrentSignalInfo
data () => MenuShellMoveSelectedSignalInfo
data () => MenuShellPrependMethodInfo
data () => MenuShellSelectFirstMethodInfo
data () => MenuShellSelectItemMethodInfo
data () => MenuShellSelectionDoneSignalInfo
data () => MenuShellSetTakeFocusMethodInfo
data () => MenuShellTakeFocusPropertyInfo
type family ResolveMenuShellMethod (t :: Symbol) o
type family ResolveMenuShellAccessibleMethod (t :: Symbol) o
data () => MenuToolButtonGetMenuMethodInfo
data () => MenuToolButtonMenuPropertyInfo
data () => MenuToolButtonSetArrowTooltipMarkupMethodInfo
data () => MenuToolButtonSetArrowTooltipTextMethodInfo
data () => MenuToolButtonSetMenuMethodInfo
data () => MenuToolButtonShowMenuSignalInfo
type family ResolveMenuToolButtonMethod (t :: Symbol) o
data () => MessageDialogButtonsPropertyInfo
data () => MessageDialogGetImageMethodInfo
data () => MessageDialogGetMessageAreaMethodInfo
data () => MessageDialogImagePropertyInfo
data () => MessageDialogMessageAreaPropertyInfo
data () => MessageDialogMessageTypePropertyInfo
data () => MessageDialogSecondaryTextPropertyInfo
data () => MessageDialogSecondaryUseMarkupPropertyInfo
data () => MessageDialogSetImageMethodInfo
data () => MessageDialogSetMarkupMethodInfo
data () => MessageDialogTextPropertyInfo
data () => MessageDialogUseMarkupPropertyInfo
type family ResolveMessageDialogMethod (t :: Symbol) o
data () => MiscGetAlignmentMethodInfo
data () => MiscGetPaddingMethodInfo
data () => MiscSetAlignmentMethodInfo
data () => MiscSetPaddingMethodInfo
data () => MiscXalignPropertyInfo
data () => MiscXpadPropertyInfo
data () => MiscYalignPropertyInfo
data () => MiscYpadPropertyInfo
type family ResolveMiscMethod (t :: Symbol) o
data () => ModelButtonActivePropertyInfo
data () => ModelButtonCenteredPropertyInfo
data () => ModelButtonIconPropertyInfo
data () => ModelButtonIconicPropertyInfo
data () => ModelButtonInvertedPropertyInfo
data () => ModelButtonMenuNamePropertyInfo
data () => ModelButtonRolePropertyInfo
data () => ModelButtonTextPropertyInfo
data () => ModelButtonUseMarkupPropertyInfo
type family ResolveModelButtonMethod (t :: Symbol) o
data () => MountOperationGetParentMethodInfo
data () => MountOperationGetScreenMethodInfo
data () => MountOperationIsShowingMethodInfo
data () => MountOperationIsShowingPropertyInfo
data () => MountOperationParentPropertyInfo
data () => MountOperationScreenPropertyInfo
data () => MountOperationSetParentMethodInfo
data () => MountOperationSetScreenMethodInfo
type family ResolveMountOperationMethod (t :: Symbol) o
data () => NativeDialogDestroyMethodInfo
data () => NativeDialogGetModalMethodInfo
data () => NativeDialogGetTitleMethodInfo
data () => NativeDialogGetTransientForMethodInfo
data () => NativeDialogGetVisibleMethodInfo
data () => NativeDialogHideMethodInfo
data () => NativeDialogModalPropertyInfo
data () => NativeDialogResponseSignalInfo
data () => NativeDialogRunMethodInfo
data () => NativeDialogSetModalMethodInfo
data () => NativeDialogSetTitleMethodInfo
data () => NativeDialogSetTransientForMethodInfo
data () => NativeDialogShowMethodInfo
data () => NativeDialogTitlePropertyInfo
data () => NativeDialogTransientForPropertyInfo
data () => NativeDialogVisiblePropertyInfo
type family ResolveNativeDialogMethod (t :: Symbol) o
data () => NotebookAppendPageMenuMethodInfo
data () => NotebookAppendPageMethodInfo
data () => NotebookChangeCurrentPageSignalInfo
data () => NotebookCreateWindowSignalInfo
data () => NotebookDetachTabMethodInfo
data () => NotebookEnablePopupPropertyInfo
data () => NotebookFocusTabSignalInfo
data () => NotebookGetActionWidgetMethodInfo
data () => NotebookGetCurrentPageMethodInfo
data () => NotebookGetGroupNameMethodInfo
data () => NotebookGetMenuLabelMethodInfo
data () => NotebookGetMenuLabelTextMethodInfo
data () => NotebookGetNPagesMethodInfo
data () => NotebookGetNthPageMethodInfo
data () => NotebookGetScrollableMethodInfo
data () => NotebookGetShowBorderMethodInfo
data () => NotebookGetShowTabsMethodInfo
data () => NotebookGetTabDetachableMethodInfo
data () => NotebookGetTabHborderMethodInfo
data () => NotebookGetTabLabelMethodInfo
data () => NotebookGetTabLabelTextMethodInfo
data () => NotebookGetTabPosMethodInfo
data () => NotebookGetTabReorderableMethodInfo
data () => NotebookGetTabVborderMethodInfo
data () => NotebookGroupNamePropertyInfo
data () => NotebookInsertPageMenuMethodInfo
data () => NotebookInsertPageMethodInfo
data () => NotebookMoveFocusOutSignalInfo
data () => NotebookNextPageMethodInfo
data () => NotebookPageAddedSignalInfo
data () => NotebookPageNumMethodInfo
data () => NotebookPagePropertyInfo
data () => NotebookPageRemovedSignalInfo
data () => NotebookPageReorderedSignalInfo
data () => NotebookPopupDisableMethodInfo
data () => NotebookPopupEnableMethodInfo
data () => NotebookPrependPageMenuMethodInfo
data () => NotebookPrependPageMethodInfo
data () => NotebookPrevPageMethodInfo
data () => NotebookRemovePageMethodInfo
data () => NotebookReorderChildMethodInfo
data () => NotebookReorderTabSignalInfo
data () => NotebookScrollablePropertyInfo
data () => NotebookSelectPageSignalInfo
data () => NotebookSetActionWidgetMethodInfo
data () => NotebookSetCurrentPageMethodInfo
data () => NotebookSetGroupNameMethodInfo
data () => NotebookSetMenuLabelMethodInfo
data () => NotebookSetMenuLabelTextMethodInfo
data () => NotebookSetScrollableMethodInfo
data () => NotebookSetShowBorderMethodInfo
data () => NotebookSetShowTabsMethodInfo
data () => NotebookSetTabDetachableMethodInfo
data () => NotebookSetTabLabelMethodInfo
data () => NotebookSetTabLabelTextMethodInfo
data () => NotebookSetTabPosMethodInfo
data () => NotebookSetTabReorderableMethodInfo
data () => NotebookShowBorderPropertyInfo
data () => NotebookShowTabsPropertyInfo
data () => NotebookSwitchPageSignalInfo
data () => NotebookTabPosPropertyInfo
type family ResolveNotebookMethod (t :: Symbol) o
type family ResolveNotebookAccessibleMethod (t :: Symbol) o
data () => NotebookPageAccessibleInvalidateMethodInfo
type family ResolveNotebookPageAccessibleMethod (t :: Symbol) o
data () => NumerableIconBackgroundIconNamePropertyInfo
data () => NumerableIconBackgroundIconPropertyInfo
data () => NumerableIconCountPropertyInfo
data () => NumerableIconGetBackgroundGiconMethodInfo
data () => NumerableIconGetBackgroundIconNameMethodInfo
data () => NumerableIconGetCountMethodInfo
data () => NumerableIconGetLabelMethodInfo
data () => NumerableIconGetStyleContextMethodInfo
data () => NumerableIconLabelPropertyInfo
data () => NumerableIconSetBackgroundGiconMethodInfo
data () => NumerableIconSetBackgroundIconNameMethodInfo
data () => NumerableIconSetCountMethodInfo
data () => NumerableIconSetLabelMethodInfo
data () => NumerableIconSetStyleContextMethodInfo
data () => NumerableIconStyleContextPropertyInfo
type family ResolveNumerableIconMethod (t :: Symbol) o
data () => OffscreenWindowGetPixbufMethodInfo
data () => OffscreenWindowGetSurfaceMethodInfo
type family ResolveOffscreenWindowMethod (t :: Symbol) o
data () => OverlayAddOverlayMethodInfo
data () => OverlayGetChildPositionSignalInfo
data () => OverlayGetOverlayPassThroughMethodInfo
data () => OverlayReorderOverlayMethodInfo
data () => OverlaySetOverlayPassThroughMethodInfo
type family ResolveOverlayMethod (t :: Symbol) o
data () => PadControllerActionGroupPropertyInfo
data () => PadControllerPadPropertyInfo
data () => PadControllerSetActionEntriesMethodInfo
data () => PadControllerSetActionMethodInfo
type family ResolvePadControllerMethod (t :: Symbol) o
data () => PageSetupCopyMethodInfo
data () => PageSetupGetBottomMarginMethodInfo
data () => PageSetupGetLeftMarginMethodInfo
data () => PageSetupGetOrientationMethodInfo
data () => PageSetupGetPageHeightMethodInfo
data () => PageSetupGetPageWidthMethodInfo
data () => PageSetupGetPaperHeightMethodInfo
data () => PageSetupGetPaperSizeMethodInfo
data () => PageSetupGetPaperWidthMethodInfo
data () => PageSetupGetRightMarginMethodInfo
data () => PageSetupGetTopMarginMethodInfo
data () => PageSetupLoadFileMethodInfo
data () => PageSetupLoadKeyFileMethodInfo
data () => PageSetupSetBottomMarginMethodInfo
data () => PageSetupSetLeftMarginMethodInfo
data () => PageSetupSetOrientationMethodInfo
data () => PageSetupSetPaperSizeAndDefaultMarginsMethodInfo
data () => PageSetupSetPaperSizeMethodInfo
data () => PageSetupSetRightMarginMethodInfo
data () => PageSetupSetTopMarginMethodInfo
data () => PageSetupToFileMethodInfo
data () => PageSetupToGvariantMethodInfo
data () => PageSetupToKeyFileMethodInfo
type family ResolvePageSetupMethod (t :: Symbol) o
data () => PanedAcceptPositionSignalInfo
data () => PanedAdd1MethodInfo
data () => PanedAdd2MethodInfo
data () => PanedCancelPositionSignalInfo
data () => PanedCycleChildFocusSignalInfo
data () => PanedCycleHandleFocusSignalInfo
data () => PanedGetChild1MethodInfo
data () => PanedGetChild2MethodInfo
data () => PanedGetHandleWindowMethodInfo
data () => PanedGetPositionMethodInfo
data () => PanedGetWideHandleMethodInfo
data () => PanedMaxPositionPropertyInfo
data () => PanedMinPositionPropertyInfo
data () => PanedMoveHandleSignalInfo
data () => PanedPack1MethodInfo
data () => PanedPack2MethodInfo
data () => PanedPositionPropertyInfo
data () => PanedPositionSetPropertyInfo
data () => PanedSetPositionMethodInfo
data () => PanedSetWideHandleMethodInfo
data () => PanedToggleHandleFocusSignalInfo
data () => PanedWideHandlePropertyInfo
type family ResolvePanedMethod (t :: Symbol) o
type family ResolvePanedAccessibleMethod (t :: Symbol) o
data () => PlacesSidebarAddShortcutMethodInfo
data () => PlacesSidebarDragActionAskSignalInfo
data () => PlacesSidebarDragActionRequestedSignalInfo
data () => PlacesSidebarDragPerformDropSignalInfo
data () => PlacesSidebarGetLocalOnlyMethodInfo
data () => PlacesSidebarGetLocationMethodInfo
data () => PlacesSidebarGetNthBookmarkMethodInfo
data () => PlacesSidebarGetOpenFlagsMethodInfo
data () => PlacesSidebarGetShowConnectToServerMethodInfo
data () => PlacesSidebarGetShowDesktopMethodInfo
data () => PlacesSidebarGetShowEnterLocationMethodInfo
data () => PlacesSidebarGetShowOtherLocationsMethodInfo
data () => PlacesSidebarGetShowRecentMethodInfo
data () => PlacesSidebarGetShowStarredLocationMethodInfo
data () => PlacesSidebarGetShowTrashMethodInfo
data () => PlacesSidebarListShortcutsMethodInfo
data () => PlacesSidebarLocalOnlyPropertyInfo
data () => PlacesSidebarLocationPropertyInfo
data () => PlacesSidebarMountSignalInfo
data () => PlacesSidebarOpenFlagsPropertyInfo
data () => PlacesSidebarOpenLocationSignalInfo
data () => PlacesSidebarPopulateAllPropertyInfo
data () => PlacesSidebarPopulatePopupSignalInfo
data () => PlacesSidebarRemoveShortcutMethodInfo
data () => PlacesSidebarSetDropTargetsVisibleMethodInfo
data () => PlacesSidebarSetLocalOnlyMethodInfo
data () => PlacesSidebarSetLocationMethodInfo
data () => PlacesSidebarSetOpenFlagsMethodInfo
data () => PlacesSidebarSetShowConnectToServerMethodInfo
data () => PlacesSidebarSetShowDesktopMethodInfo
data () => PlacesSidebarSetShowEnterLocationMethodInfo
data () => PlacesSidebarSetShowOtherLocationsMethodInfo
data () => PlacesSidebarSetShowRecentMethodInfo
data () => PlacesSidebarSetShowStarredLocationMethodInfo
data () => PlacesSidebarSetShowTrashMethodInfo
data () => PlacesSidebarShowConnectToServerPropertyInfo
data () => PlacesSidebarShowConnectToServerSignalInfo
data () => PlacesSidebarShowDesktopPropertyInfo
data () => PlacesSidebarShowEnterLocationPropertyInfo
data () => PlacesSidebarShowEnterLocationSignalInfo
data () => PlacesSidebarShowErrorMessageSignalInfo
data () => PlacesSidebarShowOtherLocationsPropertyInfo
data () => PlacesSidebarShowOtherLocationsSignalInfo
data () => PlacesSidebarShowOtherLocationsWithFlagsSignalInfo
data () => PlacesSidebarShowRecentPropertyInfo
data () => PlacesSidebarShowStarredLocationPropertyInfo
data () => PlacesSidebarShowStarredLocationSignalInfo
data () => PlacesSidebarShowTrashPropertyInfo
data () => PlacesSidebarUnmountSignalInfo
type family ResolvePlacesSidebarMethod (t :: Symbol) o
data () => PlugConstructForDisplayMethodInfo
data () => PlugConstructMethodInfo
data () => PlugEmbeddedPropertyInfo
data () => PlugEmbeddedSignalInfo
data () => PlugGetEmbeddedMethodInfo
data () => PlugGetIdMethodInfo
data () => PlugGetSocketWindowMethodInfo
data () => PlugSocketWindowPropertyInfo
type family ResolvePlugMethod (t :: Symbol) o
data () => PlugAccessibleGetIdMethodInfo
type family ResolvePlugAccessibleMethod (t :: Symbol) o
data () => PopoverBindModelMethodInfo
data () => PopoverClosedSignalInfo
data () => PopoverConstrainToPropertyInfo
data () => PopoverGetConstrainToMethodInfo
data () => PopoverGetDefaultWidgetMethodInfo
data () => PopoverGetModalMethodInfo
data () => PopoverGetPointingToMethodInfo
data () => PopoverGetPositionMethodInfo
data () => PopoverGetRelativeToMethodInfo
data () => PopoverGetTransitionsEnabledMethodInfo
data () => PopoverModalPropertyInfo
data () => PopoverPointingToPropertyInfo
data () => PopoverPopdownMethodInfo
data () => PopoverPopupMethodInfo
data () => PopoverPositionPropertyInfo
data () => PopoverRelativeToPropertyInfo
data () => PopoverSetConstrainToMethodInfo
data () => PopoverSetDefaultWidgetMethodInfo
data () => PopoverSetModalMethodInfo
data () => PopoverSetPointingToMethodInfo
data () => PopoverSetPositionMethodInfo
data () => PopoverSetRelativeToMethodInfo
data () => PopoverSetTransitionsEnabledMethodInfo
data () => PopoverTransitionsEnabledPropertyInfo
type family ResolvePopoverMethod (t :: Symbol) o
type family ResolvePopoverAccessibleMethod (t :: Symbol) o
data () => PopoverMenuOpenSubmenuMethodInfo
data () => PopoverMenuVisibleSubmenuPropertyInfo
type family ResolvePopoverMenuMethod (t :: Symbol) o
data () => PrintContextCreatePangoContextMethodInfo
data () => PrintContextCreatePangoLayoutMethodInfo
data () => PrintContextGetCairoContextMethodInfo
data () => PrintContextGetDpiXMethodInfo
data () => PrintContextGetDpiYMethodInfo
data () => PrintContextGetHardMarginsMethodInfo
data () => PrintContextGetHeightMethodInfo
data () => PrintContextGetPageSetupMethodInfo
data () => PrintContextGetPangoFontmapMethodInfo
data () => PrintContextGetWidthMethodInfo
data () => PrintContextSetCairoContextMethodInfo
type family ResolvePrintContextMethod (t :: Symbol) o
data () => PrintOperationAllowAsyncPropertyInfo
data () => PrintOperationBeginPrintSignalInfo
data () => PrintOperationCancelMethodInfo
data () => PrintOperationCreateCustomWidgetSignalInfo
data () => PrintOperationCurrentPagePropertyInfo
data () => PrintOperationCustomTabLabelPropertyInfo
data () => PrintOperationCustomWidgetApplySignalInfo
data () => PrintOperationDefaultPageSetupPropertyInfo
data () => PrintOperationDoneSignalInfo
data () => PrintOperationDrawPageFinishMethodInfo
data () => PrintOperationDrawPageSignalInfo
data () => PrintOperationEmbedPageSetupPropertyInfo
data () => PrintOperationEndPrintSignalInfo
data () => PrintOperationExportFilenamePropertyInfo
data () => PrintOperationGetDefaultPageSetupMethodInfo
data () => PrintOperationGetEmbedPageSetupMethodInfo
data () => PrintOperationGetErrorMethodInfo
data () => PrintOperationGetHasSelectionMethodInfo
data () => PrintOperationGetNPagesToPrintMethodInfo
data () => PrintOperationGetPrintSettingsMethodInfo
data () => PrintOperationGetStatusMethodInfo
data () => PrintOperationGetStatusStringMethodInfo
data () => PrintOperationGetSupportSelectionMethodInfo
data () => PrintOperationHasSelectionPropertyInfo
data () => PrintOperationIsFinishedMethodInfo
data () => PrintOperationJobNamePropertyInfo
data () => PrintOperationNPagesPropertyInfo
data () => PrintOperationNPagesToPrintPropertyInfo
data () => PrintOperationPaginateSignalInfo
data () => PrintOperationPreviewSignalInfo
data () => PrintOperationPrintSettingsPropertyInfo
data () => PrintOperationRequestPageSetupSignalInfo
data () => PrintOperationRunMethodInfo
data () => PrintOperationSetAllowAsyncMethodInfo
data () => PrintOperationSetCurrentPageMethodInfo
data () => PrintOperationSetCustomTabLabelMethodInfo
data () => PrintOperationSetDefaultPageSetupMethodInfo
data () => PrintOperationSetDeferDrawingMethodInfo
data () => PrintOperationSetEmbedPageSetupMethodInfo
data () => PrintOperationSetExportFilenameMethodInfo
data () => PrintOperationSetHasSelectionMethodInfo
data () => PrintOperationSetJobNameMethodInfo
data () => PrintOperationSetNPagesMethodInfo
data () => PrintOperationSetPrintSettingsMethodInfo
data () => PrintOperationSetShowProgressMethodInfo
data () => PrintOperationSetSupportSelectionMethodInfo
data () => PrintOperationSetTrackPrintStatusMethodInfo
data () => PrintOperationSetUnitMethodInfo
data () => PrintOperationSetUseFullPageMethodInfo
data () => PrintOperationShowProgressPropertyInfo
data () => PrintOperationStatusChangedSignalInfo
data () => PrintOperationStatusPropertyInfo
data () => PrintOperationStatusStringPropertyInfo
data () => PrintOperationSupportSelectionPropertyInfo
data () => PrintOperationTrackPrintStatusPropertyInfo
data () => PrintOperationUnitPropertyInfo
data () => PrintOperationUpdateCustomWidgetSignalInfo
data () => PrintOperationUseFullPagePropertyInfo
type family ResolvePrintOperationMethod (t :: Symbol) o
data () => PrintSettingsCopyMethodInfo
data () => PrintSettingsForeachMethodInfo
data () => PrintSettingsGetBoolMethodInfo
data () => PrintSettingsGetCollateMethodInfo
data () => PrintSettingsGetDefaultSourceMethodInfo
data () => PrintSettingsGetDitherMethodInfo
data () => PrintSettingsGetDoubleMethodInfo
data () => PrintSettingsGetDoubleWithDefaultMethodInfo
data () => PrintSettingsGetDuplexMethodInfo
data () => PrintSettingsGetFinishingsMethodInfo
data () => PrintSettingsGetIntMethodInfo
data () => PrintSettingsGetIntWithDefaultMethodInfo
data () => PrintSettingsGetLengthMethodInfo
data () => PrintSettingsGetMediaTypeMethodInfo
data () => PrintSettingsGetMethodInfo
data () => PrintSettingsGetNCopiesMethodInfo
data () => PrintSettingsGetNumberUpLayoutMethodInfo
data () => PrintSettingsGetNumberUpMethodInfo
data () => PrintSettingsGetOrientationMethodInfo
data () => PrintSettingsGetOutputBinMethodInfo
data () => PrintSettingsGetPageRangesMethodInfo
data () => PrintSettingsGetPageSetMethodInfo
data () => PrintSettingsGetPaperHeightMethodInfo
data () => PrintSettingsGetPaperSizeMethodInfo
data () => PrintSettingsGetPaperWidthMethodInfo
data () => PrintSettingsGetPrintPagesMethodInfo
data () => PrintSettingsGetPrinterLpiMethodInfo
data () => PrintSettingsGetPrinterMethodInfo
data () => PrintSettingsGetQualityMethodInfo
data () => PrintSettingsGetResolutionMethodInfo
data () => PrintSettingsGetResolutionXMethodInfo
data () => PrintSettingsGetResolutionYMethodInfo
data () => PrintSettingsGetReverseMethodInfo
data () => PrintSettingsGetScaleMethodInfo
data () => PrintSettingsGetUseColorMethodInfo
data () => PrintSettingsHasKeyMethodInfo
data () => PrintSettingsLoadFileMethodInfo
data () => PrintSettingsLoadKeyFileMethodInfo
data () => PrintSettingsSetBoolMethodInfo
data () => PrintSettingsSetCollateMethodInfo
data () => PrintSettingsSetDefaultSourceMethodInfo
data () => PrintSettingsSetDitherMethodInfo
data () => PrintSettingsSetDoubleMethodInfo
data () => PrintSettingsSetDuplexMethodInfo
data () => PrintSettingsSetFinishingsMethodInfo
data () => PrintSettingsSetIntMethodInfo
data () => PrintSettingsSetLengthMethodInfo
data () => PrintSettingsSetMediaTypeMethodInfo
data () => PrintSettingsSetMethodInfo
data () => PrintSettingsSetNCopiesMethodInfo
data () => PrintSettingsSetNumberUpLayoutMethodInfo
data () => PrintSettingsSetNumberUpMethodInfo
data () => PrintSettingsSetOrientationMethodInfo
data () => PrintSettingsSetOutputBinMethodInfo
data () => PrintSettingsSetPageRangesMethodInfo
data () => PrintSettingsSetPageSetMethodInfo
data () => PrintSettingsSetPaperHeightMethodInfo
data () => PrintSettingsSetPaperSizeMethodInfo
data () => PrintSettingsSetPaperWidthMethodInfo
data () => PrintSettingsSetPrintPagesMethodInfo
data () => PrintSettingsSetPrinterLpiMethodInfo
data () => PrintSettingsSetPrinterMethodInfo
data () => PrintSettingsSetQualityMethodInfo
data () => PrintSettingsSetResolutionMethodInfo
data () => PrintSettingsSetResolutionXyMethodInfo
data () => PrintSettingsSetReverseMethodInfo
data () => PrintSettingsSetScaleMethodInfo
data () => PrintSettingsSetUseColorMethodInfo
data () => PrintSettingsToFileMethodInfo
data () => PrintSettingsToGvariantMethodInfo
data () => PrintSettingsToKeyFileMethodInfo
data () => PrintSettingsUnsetMethodInfo
type family ResolvePrintSettingsMethod (t :: Symbol) o
data () => ProgressBarEllipsizePropertyInfo
data () => ProgressBarFractionPropertyInfo
data () => ProgressBarGetEllipsizeMethodInfo
data () => ProgressBarGetFractionMethodInfo
data () => ProgressBarGetInvertedMethodInfo
data () => ProgressBarGetPulseStepMethodInfo
data () => ProgressBarGetShowTextMethodInfo
data () => ProgressBarGetTextMethodInfo
data () => ProgressBarInvertedPropertyInfo
data () => ProgressBarPulseMethodInfo
data () => ProgressBarPulseStepPropertyInfo
data () => ProgressBarSetEllipsizeMethodInfo
data () => ProgressBarSetFractionMethodInfo
data () => ProgressBarSetInvertedMethodInfo
data () => ProgressBarSetPulseStepMethodInfo
data () => ProgressBarSetShowTextMethodInfo
data () => ProgressBarSetTextMethodInfo
data () => ProgressBarShowTextPropertyInfo
data () => ProgressBarTextPropertyInfo
type family ResolveProgressBarMethod (t :: Symbol) o
type family ResolveProgressBarAccessibleMethod (t :: Symbol) o
data () => RadioActionChangedSignalInfo
data () => RadioActionCurrentValuePropertyInfo
data () => RadioActionGetCurrentValueMethodInfo
data () => RadioActionGetGroupMethodInfo
data () => RadioActionGroupPropertyInfo
data () => RadioActionJoinGroupMethodInfo
data () => RadioActionSetCurrentValueMethodInfo
data () => RadioActionSetGroupMethodInfo
data () => RadioActionValuePropertyInfo
type family ResolveRadioActionMethod (t :: Symbol) o
data () => RadioButtonGetGroupMethodInfo
data () => RadioButtonGroupChangedSignalInfo
data () => RadioButtonGroupPropertyInfo
data () => RadioButtonJoinGroupMethodInfo
data () => RadioButtonSetGroupMethodInfo
type family ResolveRadioButtonMethod (t :: Symbol) o
type family ResolveRadioButtonAccessibleMethod (t :: Symbol) o
data () => RadioMenuItemGetGroupMethodInfo
data () => RadioMenuItemGroupChangedSignalInfo
data () => RadioMenuItemGroupPropertyInfo
data () => RadioMenuItemJoinGroupMethodInfo
data () => RadioMenuItemSetGroupMethodInfo
type family ResolveRadioMenuItemMethod (t :: Symbol) o
type family ResolveRadioMenuItemAccessibleMethod (t :: Symbol) o
data () => RadioToolButtonGetGroupMethodInfo
data () => RadioToolButtonGroupPropertyInfo
data () => RadioToolButtonSetGroupMethodInfo
type family ResolveRadioToolButtonMethod (t :: Symbol) o
data () => RangeAdjustBoundsSignalInfo
data () => RangeAdjustmentPropertyInfo
data () => RangeChangeValueSignalInfo
data () => RangeFillLevelPropertyInfo
data () => RangeGetAdjustmentMethodInfo
data () => RangeGetFillLevelMethodInfo
data () => RangeGetFlippableMethodInfo
data () => RangeGetInvertedMethodInfo
data () => RangeGetLowerStepperSensitivityMethodInfo
data () => RangeGetMinSliderSizeMethodInfo
data () => RangeGetRangeRectMethodInfo
data () => RangeGetRestrictToFillLevelMethodInfo
data () => RangeGetRoundDigitsMethodInfo
data () => RangeGetShowFillLevelMethodInfo
data () => RangeGetSliderRangeMethodInfo
data () => RangeGetSliderSizeFixedMethodInfo
data () => RangeGetUpperStepperSensitivityMethodInfo
data () => RangeGetValueMethodInfo
data () => RangeInvertedPropertyInfo
data () => RangeLowerStepperSensitivityPropertyInfo
data () => RangeMoveSliderSignalInfo
data () => RangeRestrictToFillLevelPropertyInfo
data () => RangeRoundDigitsPropertyInfo
data () => RangeSetAdjustmentMethodInfo
data () => RangeSetFillLevelMethodInfo
data () => RangeSetFlippableMethodInfo
data () => RangeSetIncrementsMethodInfo
data () => RangeSetInvertedMethodInfo
data () => RangeSetLowerStepperSensitivityMethodInfo
data () => RangeSetMinSliderSizeMethodInfo
data () => RangeSetRangeMethodInfo
data () => RangeSetRestrictToFillLevelMethodInfo
data () => RangeSetRoundDigitsMethodInfo
data () => RangeSetShowFillLevelMethodInfo
data () => RangeSetSliderSizeFixedMethodInfo
data () => RangeSetUpperStepperSensitivityMethodInfo
data () => RangeSetValueMethodInfo
data () => RangeShowFillLevelPropertyInfo
data () => RangeUpperStepperSensitivityPropertyInfo
data () => RangeValueChangedSignalInfo
type family ResolveRangeMethod (t :: Symbol) o
type family ResolveRangeAccessibleMethod (t :: Symbol) o
data () => RcStyleCopyMethodInfo
type family ResolveRcStyleMethod (t :: Symbol) o
data () => RecentActionGetShowNumbersMethodInfo
data () => RecentActionSetShowNumbersMethodInfo
data () => RecentActionShowNumbersPropertyInfo
type family ResolveRecentActionMethod (t :: Symbol) o
type family ResolveRecentChooserDialogMethod (t :: Symbol) o
data () => RecentChooserMenuGetShowNumbersMethodInfo
data () => RecentChooserMenuSetShowNumbersMethodInfo
data () => RecentChooserMenuShowNumbersPropertyInfo
type family ResolveRecentChooserMenuMethod (t :: Symbol) o
type family ResolveRecentChooserWidgetMethod (t :: Symbol) o
data () => RecentFilterAddAgeMethodInfo
data () => RecentFilterAddApplicationMethodInfo
data () => RecentFilterAddCustomMethodInfo
data () => RecentFilterAddGroupMethodInfo
data () => RecentFilterAddMimeTypeMethodInfo
data () => RecentFilterAddPatternMethodInfo
data () => RecentFilterAddPixbufFormatsMethodInfo
data () => RecentFilterFilterMethodInfo
data () => RecentFilterGetNameMethodInfo
data () => RecentFilterGetNeededMethodInfo
data () => RecentFilterSetNameMethodInfo
type family ResolveRecentFilterMethod (t :: Symbol) o
data () => RecentManagerAddFullMethodInfo
data () => RecentManagerAddItemMethodInfo
data () => RecentManagerChangedSignalInfo
data () => RecentManagerFilenamePropertyInfo
data () => RecentManagerGetItemsMethodInfo
data () => RecentManagerHasItemMethodInfo
data () => RecentManagerLookupItemMethodInfo
data () => RecentManagerMoveItemMethodInfo
data () => RecentManagerPurgeItemsMethodInfo
data () => RecentManagerRemoveItemMethodInfo
data () => RecentManagerSizePropertyInfo
type family ResolveRecentManagerMethod (t :: Symbol) o
data () => RendererCellAccessibleRendererPropertyInfo
type family ResolveRendererCellAccessibleMethod (t :: Symbol) o
type family ResolveRevealerMethod (t :: Symbol) o
data () => RevealerChildRevealedPropertyInfo
data () => RevealerGetChildRevealedMethodInfo
data () => RevealerGetRevealChildMethodInfo
data () => RevealerGetTransitionDurationMethodInfo
data () => RevealerGetTransitionTypeMethodInfo
data () => RevealerRevealChildPropertyInfo
data () => RevealerSetRevealChildMethodInfo
data () => RevealerSetTransitionDurationMethodInfo
data () => RevealerSetTransitionTypeMethodInfo
data () => RevealerTransitionDurationPropertyInfo
data () => RevealerTransitionTypePropertyInfo
type family ResolveScaleMethod (t :: Symbol) o
data () => ScaleAddMarkMethodInfo
data () => ScaleClearMarksMethodInfo
data () => ScaleDigitsPropertyInfo
data () => ScaleDrawValuePropertyInfo
data () => ScaleFormatValueSignalInfo
data () => ScaleGetDigitsMethodInfo
data () => ScaleGetDrawValueMethodInfo
data () => ScaleGetHasOriginMethodInfo
data () => ScaleGetLayoutMethodInfo
data () => ScaleGetLayoutOffsetsMethodInfo
data () => ScaleGetValuePosMethodInfo
data () => ScaleHasOriginPropertyInfo
data () => ScaleSetDigitsMethodInfo
data () => ScaleSetDrawValueMethodInfo
data () => ScaleSetHasOriginMethodInfo
data () => ScaleSetValuePosMethodInfo
data () => ScaleValuePosPropertyInfo
type family ResolveScaleAccessibleMethod (t :: Symbol) o
type family ResolveScaleButtonMethod (t :: Symbol) o
data () => ScaleButtonAdjustmentPropertyInfo
data () => ScaleButtonGetAdjustmentMethodInfo
data () => ScaleButtonGetMinusButtonMethodInfo
data () => ScaleButtonGetPlusButtonMethodInfo
data () => ScaleButtonGetPopupMethodInfo
data () => ScaleButtonGetValueMethodInfo
data () => ScaleButtonIconsPropertyInfo
data () => ScaleButtonPopdownSignalInfo
data () => ScaleButtonPopupSignalInfo
data () => ScaleButtonSetAdjustmentMethodInfo
data () => ScaleButtonSetIconsMethodInfo
data () => ScaleButtonSetValueMethodInfo
data () => ScaleButtonSizePropertyInfo
data () => ScaleButtonValueChangedSignalInfo
data () => ScaleButtonValuePropertyInfo
type family ResolveScaleButtonAccessibleMethod (t :: Symbol) o
type family ResolveScrollbarMethod (t :: Symbol) o
type family ResolveScrolledWindowMethod (t :: Symbol) o
data () => ScrolledWindowAddWithViewportMethodInfo
data () => ScrolledWindowEdgeOvershotSignalInfo
data () => ScrolledWindowEdgeReachedSignalInfo
data () => ScrolledWindowGetCaptureButtonPressMethodInfo
data () => ScrolledWindowGetHadjustmentMethodInfo
data () => ScrolledWindowGetHscrollbarMethodInfo
data () => ScrolledWindowGetKineticScrollingMethodInfo
data () => ScrolledWindowGetMaxContentHeightMethodInfo
data () => ScrolledWindowGetMaxContentWidthMethodInfo
data () => ScrolledWindowGetMinContentHeightMethodInfo
data () => ScrolledWindowGetMinContentWidthMethodInfo
data () => ScrolledWindowGetOverlayScrollingMethodInfo
data () => ScrolledWindowGetPlacementMethodInfo
data () => ScrolledWindowGetPolicyMethodInfo
data () => ScrolledWindowGetPropagateNaturalHeightMethodInfo
data () => ScrolledWindowGetPropagateNaturalWidthMethodInfo
data () => ScrolledWindowGetShadowTypeMethodInfo
data () => ScrolledWindowGetVadjustmentMethodInfo
data () => ScrolledWindowGetVscrollbarMethodInfo
data () => ScrolledWindowHadjustmentPropertyInfo
data () => ScrolledWindowHscrollbarPolicyPropertyInfo
data () => ScrolledWindowKineticScrollingPropertyInfo
data () => ScrolledWindowMaxContentHeightPropertyInfo
data () => ScrolledWindowMaxContentWidthPropertyInfo
data () => ScrolledWindowMinContentHeightPropertyInfo
data () => ScrolledWindowMinContentWidthPropertyInfo
data () => ScrolledWindowMoveFocusOutSignalInfo
data () => ScrolledWindowOverlayScrollingPropertyInfo
data () => ScrolledWindowPropagateNaturalHeightPropertyInfo
data () => ScrolledWindowPropagateNaturalWidthPropertyInfo
data () => ScrolledWindowScrollChildSignalInfo
data () => ScrolledWindowSetCaptureButtonPressMethodInfo
data () => ScrolledWindowSetHadjustmentMethodInfo
data () => ScrolledWindowSetKineticScrollingMethodInfo
data () => ScrolledWindowSetMaxContentHeightMethodInfo
data () => ScrolledWindowSetMaxContentWidthMethodInfo
data () => ScrolledWindowSetMinContentHeightMethodInfo
data () => ScrolledWindowSetMinContentWidthMethodInfo
data () => ScrolledWindowSetOverlayScrollingMethodInfo
data () => ScrolledWindowSetPlacementMethodInfo
data () => ScrolledWindowSetPolicyMethodInfo
data () => ScrolledWindowSetPropagateNaturalHeightMethodInfo
data () => ScrolledWindowSetPropagateNaturalWidthMethodInfo
data () => ScrolledWindowSetShadowTypeMethodInfo
data () => ScrolledWindowSetVadjustmentMethodInfo
data () => ScrolledWindowShadowTypePropertyInfo
data () => ScrolledWindowUnsetPlacementMethodInfo
data () => ScrolledWindowVadjustmentPropertyInfo
data () => ScrolledWindowVscrollbarPolicyPropertyInfo
data () => ScrolledWindowWindowPlacementPropertyInfo
data () => ScrolledWindowWindowPlacementSetPropertyInfo
type family ResolveScrolledWindowAccessibleMethod (t :: Symbol) o
type family ResolveSearchBarMethod (t :: Symbol) o
data () => SearchBarConnectEntryMethodInfo
data () => SearchBarGetSearchModeMethodInfo
data () => SearchBarGetShowCloseButtonMethodInfo
data () => SearchBarHandleEventMethodInfo
data () => SearchBarSearchModeEnabledPropertyInfo
data () => SearchBarSetSearchModeMethodInfo
data () => SearchBarSetShowCloseButtonMethodInfo
data () => SearchBarShowCloseButtonPropertyInfo
type family ResolveSearchEntryMethod (t :: Symbol) o
data () => SearchEntryHandleEventMethodInfo
data () => SearchEntryNextMatchSignalInfo
data () => SearchEntryPreviousMatchSignalInfo
data () => SearchEntrySearchChangedSignalInfo
data () => SearchEntryStopSearchSignalInfo
type family ResolveSeparatorMethod (t :: Symbol) o
type family ResolveSeparatorMenuItemMethod (t :: Symbol) o
type family ResolveSeparatorToolItemMethod (t :: Symbol) o
data () => SeparatorToolItemDrawPropertyInfo
data () => SeparatorToolItemGetDrawMethodInfo
data () => SeparatorToolItemSetDrawMethodInfo
type family ResolveSettingsMethod (t :: Symbol) o
data () => SettingsColorHashPropertyInfo
data () => SettingsGtkAlternativeButtonOrderPropertyInfo
data () => SettingsGtkAlternativeSortArrowsPropertyInfo
data () => SettingsGtkApplicationPreferDarkThemePropertyInfo
data () => SettingsGtkAutoMnemonicsPropertyInfo
data () => SettingsGtkButtonImagesPropertyInfo
data () => SettingsGtkCanChangeAccelsPropertyInfo
data () => SettingsGtkColorPalettePropertyInfo
data () => SettingsGtkColorSchemePropertyInfo
data () => SettingsGtkCursorAspectRatioPropertyInfo
data () => SettingsGtkCursorBlinkPropertyInfo
data () => SettingsGtkCursorBlinkTimePropertyInfo
data () => SettingsGtkCursorBlinkTimeoutPropertyInfo
data () => SettingsGtkCursorThemeNamePropertyInfo
data () => SettingsGtkCursorThemeSizePropertyInfo
data () => SettingsGtkDecorationLayoutPropertyInfo
data () => SettingsGtkDialogsUseHeaderPropertyInfo
data () => SettingsGtkDndDragThresholdPropertyInfo
data () => SettingsGtkDoubleClickDistancePropertyInfo
data () => SettingsGtkDoubleClickTimePropertyInfo
data () => SettingsGtkEnableAccelsPropertyInfo
data () => SettingsGtkEnableAnimationsPropertyInfo
data () => SettingsGtkEnableEventSoundsPropertyInfo
data () => SettingsGtkEnableInputFeedbackSoundsPropertyInfo
data () => SettingsGtkEnableMnemonicsPropertyInfo
data () => SettingsGtkEnablePrimaryPastePropertyInfo
data () => SettingsGtkEnableTooltipsPropertyInfo
data () => SettingsGtkEntryPasswordHintTimeoutPropertyInfo
data () => SettingsGtkEntrySelectOnFocusPropertyInfo
data () => SettingsGtkErrorBellPropertyInfo
data () => SettingsGtkFallbackIconThemePropertyInfo
data () => SettingsGtkFileChooserBackendPropertyInfo
data () => SettingsGtkFontNamePropertyInfo
data () => SettingsGtkFontconfigTimestampPropertyInfo
data () => SettingsGtkIconSizesPropertyInfo
data () => SettingsGtkIconThemeNamePropertyInfo
data () => SettingsGtkImModulePropertyInfo
data () => SettingsGtkImPreeditStylePropertyInfo
data () => SettingsGtkImStatusStylePropertyInfo
data () => SettingsGtkKeyThemeNamePropertyInfo
data () => SettingsGtkKeynavCursorOnlyPropertyInfo
data () => SettingsGtkKeynavUseCaretPropertyInfo
data () => SettingsGtkKeynavWrapAroundPropertyInfo
data () => SettingsGtkLabelSelectOnFocusPropertyInfo
data () => SettingsGtkLongPressTimePropertyInfo
data () => SettingsGtkMenuBarAccelPropertyInfo
data () => SettingsGtkMenuBarPopupDelayPropertyInfo
data () => SettingsGtkMenuImagesPropertyInfo
data () => SettingsGtkMenuPopdownDelayPropertyInfo
data () => SettingsGtkMenuPopupDelayPropertyInfo
data () => SettingsGtkModulesPropertyInfo
data () => SettingsGtkOverlayScrollingPropertyInfo
data () => SettingsGtkPrimaryButtonWarpsSliderPropertyInfo
data () => SettingsGtkPrintBackendsPropertyInfo
data () => SettingsGtkPrintPreviewCommandPropertyInfo
data () => SettingsGtkRecentFilesEnabledPropertyInfo
data () => SettingsGtkRecentFilesLimitPropertyInfo
data () => SettingsGtkRecentFilesMaxAgePropertyInfo
data () => SettingsGtkScrolledWindowPlacementPropertyInfo
data () => SettingsGtkShellShowsAppMenuPropertyInfo
data () => SettingsGtkShellShowsDesktopPropertyInfo
data () => SettingsGtkShellShowsMenubarPropertyInfo
data () => SettingsGtkShowInputMethodMenuPropertyInfo
data () => SettingsGtkShowUnicodeMenuPropertyInfo
data () => SettingsGtkSoundThemeNamePropertyInfo
data () => SettingsGtkSplitCursorPropertyInfo
data () => SettingsGtkThemeNamePropertyInfo
data () => SettingsGtkTimeoutExpandPropertyInfo
data () => SettingsGtkTimeoutInitialPropertyInfo
data () => SettingsGtkTimeoutRepeatPropertyInfo
data () => SettingsGtkTitlebarDoubleClickPropertyInfo
data () => SettingsGtkTitlebarMiddleClickPropertyInfo
data () => SettingsGtkTitlebarRightClickPropertyInfo
data () => SettingsGtkToolbarIconSizePropertyInfo
data () => SettingsGtkToolbarStylePropertyInfo
data () => SettingsGtkTooltipBrowseModeTimeoutPropertyInfo
data () => SettingsGtkTooltipBrowseTimeoutPropertyInfo
data () => SettingsGtkTooltipTimeoutPropertyInfo
data () => SettingsGtkTouchscreenModePropertyInfo
data () => SettingsGtkVisibleFocusPropertyInfo
data () => SettingsGtkXftAntialiasPropertyInfo
data () => SettingsGtkXftDpiPropertyInfo
data () => SettingsGtkXftHintingPropertyInfo
data () => SettingsGtkXftHintstylePropertyInfo
data () => SettingsGtkXftRgbaPropertyInfo
data () => SettingsResetPropertyMethodInfo
data () => SettingsSetDoublePropertyMethodInfo
data () => SettingsSetLongPropertyMethodInfo
data () => SettingsSetPropertyValueMethodInfo
data () => SettingsSetStringPropertyMethodInfo
type family ResolveShortcutLabelMethod (t :: Symbol) o
data () => ShortcutLabelAcceleratorPropertyInfo
data () => ShortcutLabelDisabledTextPropertyInfo
data () => ShortcutLabelGetAcceleratorMethodInfo
data () => ShortcutLabelGetDisabledTextMethodInfo
data () => ShortcutLabelSetAcceleratorMethodInfo
data () => ShortcutLabelSetDisabledTextMethodInfo
type family ResolveShortcutsGroupMethod (t :: Symbol) o
data () => ShortcutsGroupAccelSizeGroupPropertyInfo
data () => ShortcutsGroupHeightPropertyInfo
data () => ShortcutsGroupTitlePropertyInfo
data () => ShortcutsGroupTitleSizeGroupPropertyInfo
data () => ShortcutsGroupViewPropertyInfo
type family ResolveShortcutsSectionMethod (t :: Symbol) o
data () => ShortcutsSectionChangeCurrentPageSignalInfo
data () => ShortcutsSectionMaxHeightPropertyInfo
data () => ShortcutsSectionSectionNamePropertyInfo
data () => ShortcutsSectionTitlePropertyInfo
data () => ShortcutsSectionViewNamePropertyInfo
type family ResolveShortcutsShortcutMethod (t :: Symbol) o
data () => ShortcutsShortcutAccelSizeGroupPropertyInfo
data () => ShortcutsShortcutAcceleratorPropertyInfo
data () => ShortcutsShortcutActionNamePropertyInfo
data () => ShortcutsShortcutDirectionPropertyInfo
data () => ShortcutsShortcutIconPropertyInfo
data () => ShortcutsShortcutIconSetPropertyInfo
data () => ShortcutsShortcutShortcutTypePropertyInfo
data () => ShortcutsShortcutSubtitlePropertyInfo
data () => ShortcutsShortcutSubtitleSetPropertyInfo
data () => ShortcutsShortcutTitlePropertyInfo
data () => ShortcutsShortcutTitleSizeGroupPropertyInfo
type family ResolveShortcutsWindowMethod (t :: Symbol) o
data () => ShortcutsWindowCloseSignalInfo
data () => ShortcutsWindowSearchSignalInfo
data () => ShortcutsWindowSectionNamePropertyInfo
data () => ShortcutsWindowViewNamePropertyInfo
type family ResolveSizeGroupMethod (t :: Symbol) o
data () => SizeGroupAddWidgetMethodInfo
data () => SizeGroupGetIgnoreHiddenMethodInfo
data () => SizeGroupGetModeMethodInfo
data () => SizeGroupGetWidgetsMethodInfo
data () => SizeGroupIgnoreHiddenPropertyInfo
data () => SizeGroupModePropertyInfo
data () => SizeGroupRemoveWidgetMethodInfo
data () => SizeGroupSetIgnoreHiddenMethodInfo
data () => SizeGroupSetModeMethodInfo
type family ResolveSocketMethod (t :: Symbol) o
data () => SocketAddIdMethodInfo
data () => SocketGetIdMethodInfo
data () => SocketGetPlugWindowMethodInfo
data () => SocketPlugAddedSignalInfo
data () => SocketPlugRemovedSignalInfo
type family ResolveSocketAccessibleMethod (t :: Symbol) o
data () => SocketAccessibleEmbedMethodInfo
type family ResolveSpinButtonMethod (t :: Symbol) o
data () => SpinButtonAdjustmentPropertyInfo
data () => SpinButtonChangeValueSignalInfo
data () => SpinButtonClimbRatePropertyInfo
data () => SpinButtonConfigureMethodInfo
data () => SpinButtonDigitsPropertyInfo
data () => SpinButtonGetAdjustmentMethodInfo
data () => SpinButtonGetDigitsMethodInfo
data () => SpinButtonGetIncrementsMethodInfo
data () => SpinButtonGetNumericMethodInfo
data () => SpinButtonGetRangeMethodInfo
data () => SpinButtonGetSnapToTicksMethodInfo
data () => SpinButtonGetUpdatePolicyMethodInfo
data () => SpinButtonGetValueAsIntMethodInfo
data () => SpinButtonGetValueMethodInfo
data () => SpinButtonGetWrapMethodInfo
data () => SpinButtonInputSignalInfo
data () => SpinButtonNumericPropertyInfo
data () => SpinButtonOutputSignalInfo
data () => SpinButtonSetAdjustmentMethodInfo
data () => SpinButtonSetDigitsMethodInfo
data () => SpinButtonSetIncrementsMethodInfo
data () => SpinButtonSetNumericMethodInfo
data () => SpinButtonSetRangeMethodInfo
data () => SpinButtonSetSnapToTicksMethodInfo
data () => SpinButtonSetUpdatePolicyMethodInfo
data () => SpinButtonSetValueMethodInfo
data () => SpinButtonSetWrapMethodInfo
data () => SpinButtonSnapToTicksPropertyInfo
data () => SpinButtonSpinMethodInfo
data () => SpinButtonUpdateMethodInfo
data () => SpinButtonUpdatePolicyPropertyInfo
data () => SpinButtonValueChangedSignalInfo
data () => SpinButtonValuePropertyInfo
data () => SpinButtonWrapPropertyInfo
data () => SpinButtonWrappedSignalInfo
type family ResolveSpinButtonAccessibleMethod (t :: Symbol) o
type family ResolveSpinnerMethod (t :: Symbol) o
data () => SpinnerActivePropertyInfo
data () => SpinnerStartMethodInfo
data () => SpinnerStopMethodInfo
type family ResolveSpinnerAccessibleMethod (t :: Symbol) o
type family ResolveStackMethod (t :: Symbol) o
data () => StackAddNamedMethodInfo
data () => StackAddTitledMethodInfo
data () => StackGetChildByNameMethodInfo
data () => StackGetHhomogeneousMethodInfo
data () => StackGetHomogeneousMethodInfo
data () => StackGetInterpolateSizeMethodInfo
data () => StackGetTransitionDurationMethodInfo
data () => StackGetTransitionRunningMethodInfo
data () => StackGetTransitionTypeMethodInfo
data () => StackGetVhomogeneousMethodInfo
data () => StackGetVisibleChildMethodInfo
data () => StackGetVisibleChildNameMethodInfo
data () => StackHhomogeneousPropertyInfo
data () => StackHomogeneousPropertyInfo
data () => StackInterpolateSizePropertyInfo
data () => StackSetHhomogeneousMethodInfo
data () => StackSetHomogeneousMethodInfo
data () => StackSetInterpolateSizeMethodInfo
data () => StackSetTransitionDurationMethodInfo
data () => StackSetTransitionTypeMethodInfo
data () => StackSetVhomogeneousMethodInfo
data () => StackSetVisibleChildFullMethodInfo
data () => StackSetVisibleChildMethodInfo
data () => StackSetVisibleChildNameMethodInfo
data () => StackTransitionDurationPropertyInfo
data () => StackTransitionRunningPropertyInfo
data () => StackTransitionTypePropertyInfo
data () => StackVhomogeneousPropertyInfo
data () => StackVisibleChildNamePropertyInfo
data () => StackVisibleChildPropertyInfo
type family ResolveStackAccessibleMethod (t :: Symbol) o
type family ResolveStackSidebarMethod (t :: Symbol) o
data () => StackSidebarGetStackMethodInfo
data () => StackSidebarSetStackMethodInfo
data () => StackSidebarStackPropertyInfo
type family ResolveStackSwitcherMethod (t :: Symbol) o
data () => StackSwitcherGetStackMethodInfo
data () => StackSwitcherIconSizePropertyInfo
data () => StackSwitcherSetStackMethodInfo
data () => StackSwitcherStackPropertyInfo
type family ResolveStatusIconMethod (t :: Symbol) o
data () => StatusIconActivateSignalInfo
data () => StatusIconButtonPressEventSignalInfo
data () => StatusIconButtonReleaseEventSignalInfo
data () => StatusIconEmbeddedPropertyInfo
data () => StatusIconFilePropertyInfo
data () => StatusIconGetGeometryMethodInfo
data () => StatusIconGetGiconMethodInfo
data () => StatusIconGetHasTooltipMethodInfo
data () => StatusIconGetIconNameMethodInfo
data () => StatusIconGetPixbufMethodInfo
data () => StatusIconGetScreenMethodInfo
data () => StatusIconGetSizeMethodInfo
data () => StatusIconGetStockMethodInfo
data () => StatusIconGetStorageTypeMethodInfo
data () => StatusIconGetTitleMethodInfo
data () => StatusIconGetTooltipMarkupMethodInfo
data () => StatusIconGetTooltipTextMethodInfo
data () => StatusIconGetVisibleMethodInfo
data () => StatusIconGetX11WindowIdMethodInfo
data () => StatusIconGiconPropertyInfo
data () => StatusIconHasTooltipPropertyInfo
data () => StatusIconIconNamePropertyInfo
data () => StatusIconIsEmbeddedMethodInfo
data () => StatusIconOrientationPropertyInfo
data () => StatusIconPixbufPropertyInfo
data () => StatusIconPopupMenuSignalInfo
data () => StatusIconQueryTooltipSignalInfo
data () => StatusIconScreenPropertyInfo
data () => StatusIconScrollEventSignalInfo
data () => StatusIconSetFromFileMethodInfo
data () => StatusIconSetFromGiconMethodInfo
data () => StatusIconSetFromIconNameMethodInfo
data () => StatusIconSetFromPixbufMethodInfo
data () => StatusIconSetFromStockMethodInfo
data () => StatusIconSetHasTooltipMethodInfo
data () => StatusIconSetNameMethodInfo
data () => StatusIconSetScreenMethodInfo
data () => StatusIconSetTitleMethodInfo
data () => StatusIconSetTooltipMarkupMethodInfo
data () => StatusIconSetTooltipTextMethodInfo
data () => StatusIconSetVisibleMethodInfo
data () => StatusIconSizeChangedSignalInfo
data () => StatusIconSizePropertyInfo
data () => StatusIconStockPropertyInfo
data () => StatusIconStorageTypePropertyInfo
data () => StatusIconTitlePropertyInfo
data () => StatusIconTooltipMarkupPropertyInfo
data () => StatusIconTooltipTextPropertyInfo
data () => StatusIconVisiblePropertyInfo
type family ResolveStatusbarMethod (t :: Symbol) o
data () => StatusbarGetContextIdMethodInfo
data () => StatusbarGetMessageAreaMethodInfo
data () => StatusbarPopMethodInfo
data () => StatusbarPushMethodInfo
data () => StatusbarRemoveAllMethodInfo
data () => StatusbarRemoveMethodInfo
data () => StatusbarTextPoppedSignalInfo
data () => StatusbarTextPushedSignalInfo
type family ResolveStatusbarAccessibleMethod (t :: Symbol) o
type family ResolveStyleMethod (t :: Symbol) o
data () => StyleApplyDefaultBackgroundMethodInfo
data () => StyleContextPropertyInfo
data () => StyleCopyMethodInfo
data () => StyleDetachMethodInfo
data () => StyleGetStylePropertyMethodInfo
data () => StyleHasContextMethodInfo
data () => StyleLookupColorMethodInfo
data () => StyleLookupIconSetMethodInfo
data () => StyleRealizeSignalInfo
data () => StyleRenderIconMethodInfo
data () => StyleSetBackgroundMethodInfo
data () => StyleUnrealizeSignalInfo
type family ResolveStyleContextMethod (t :: Symbol) o
data () => StyleContextAddClassMethodInfo
data () => StyleContextAddProviderMethodInfo
data () => StyleContextAddRegionMethodInfo
data () => StyleContextCancelAnimationsMethodInfo
data () => StyleContextChangedSignalInfo
data () => StyleContextDirectionPropertyInfo
data () => StyleContextGetBackgroundColorMethodInfo
data () => StyleContextGetBorderColorMethodInfo
data () => StyleContextGetBorderMethodInfo
data () => StyleContextGetColorMethodInfo
data () => StyleContextGetDirectionMethodInfo
data () => StyleContextGetFontMethodInfo
data () => StyleContextGetFrameClockMethodInfo
data () => StyleContextGetJunctionSidesMethodInfo
data () => StyleContextGetMarginMethodInfo
data () => StyleContextGetPaddingMethodInfo
data () => StyleContextGetParentMethodInfo
data () => StyleContextGetPathMethodInfo
data () => StyleContextGetPropertyMethodInfo
data () => StyleContextGetScaleMethodInfo
data () => StyleContextGetScreenMethodInfo
data () => StyleContextGetSectionMethodInfo
data () => StyleContextGetStateMethodInfo
data () => StyleContextGetStylePropertyMethodInfo
data () => StyleContextHasClassMethodInfo
data () => StyleContextHasRegionMethodInfo
data () => StyleContextInvalidateMethodInfo
data () => StyleContextListClassesMethodInfo
data () => StyleContextListRegionsMethodInfo
data () => StyleContextLookupColorMethodInfo
data () => StyleContextLookupIconSetMethodInfo
data () => StyleContextNotifyStateChangeMethodInfo
data () => StyleContextPaintClockPropertyInfo
data () => StyleContextParentPropertyInfo
data () => StyleContextPopAnimatableRegionMethodInfo
data () => StyleContextPushAnimatableRegionMethodInfo
data () => StyleContextRemoveClassMethodInfo
data () => StyleContextRemoveProviderMethodInfo
data () => StyleContextRemoveRegionMethodInfo
data () => StyleContextRestoreMethodInfo
data () => StyleContextSaveMethodInfo
data () => StyleContextScreenPropertyInfo
data () => StyleContextScrollAnimationsMethodInfo
data () => StyleContextSetBackgroundMethodInfo
data () => StyleContextSetDirectionMethodInfo
data () => StyleContextSetFrameClockMethodInfo
data () => StyleContextSetJunctionSidesMethodInfo
data () => StyleContextSetParentMethodInfo
data () => StyleContextSetPathMethodInfo
data () => StyleContextSetScaleMethodInfo
data () => StyleContextSetScreenMethodInfo
data () => StyleContextSetStateMethodInfo
data () => StyleContextStateIsRunningMethodInfo
data () => StyleContextToStringMethodInfo
type family ResolveStylePropertiesMethod (t :: Symbol) o
data () => StylePropertiesClearMethodInfo
data () => StylePropertiesGetPropertyMethodInfo
data () => StylePropertiesLookupColorMethodInfo
data () => StylePropertiesMapColorMethodInfo
data () => StylePropertiesMergeMethodInfo
data () => StylePropertiesSetPropertyMethodInfo
data () => StylePropertiesUnsetPropertyMethodInfo
type family ResolveSwitchMethod (t :: Symbol) o
data () => SwitchActivateSignalInfo
data () => SwitchActivePropertyInfo
data () => SwitchGetActiveMethodInfo
data () => SwitchGetStateMethodInfo
data () => SwitchSetActiveMethodInfo
data () => SwitchSetStateMethodInfo
data () => SwitchStatePropertyInfo
data () => SwitchStateSetSignalInfo
type family ResolveSwitchAccessibleMethod (t :: Symbol) o
type family ResolveTableMethod (t :: Symbol) o
data () => TableAttachDefaultsMethodInfo
data () => TableAttachMethodInfo
data () => TableColumnSpacingPropertyInfo
data () => TableGetColSpacingMethodInfo
data () => TableGetDefaultColSpacingMethodInfo
data () => TableGetDefaultRowSpacingMethodInfo
data () => TableGetHomogeneousMethodInfo
data () => TableGetRowSpacingMethodInfo
data () => TableGetSizeMethodInfo
data () => TableHomogeneousPropertyInfo
data () => TableNColumnsPropertyInfo
data () => TableNRowsPropertyInfo
data () => TableResizeMethodInfo
data () => TableRowSpacingPropertyInfo
data () => TableSetColSpacingMethodInfo
data () => TableSetColSpacingsMethodInfo
data () => TableSetHomogeneousMethodInfo
data () => TableSetRowSpacingMethodInfo
data () => TableSetRowSpacingsMethodInfo
type family ResolveTearoffMenuItemMethod (t :: Symbol) o
type family ResolveTextBufferMethod (t :: Symbol) o
data () => TextBufferAddMarkMethodInfo
data () => TextBufferAddSelectionClipboardMethodInfo
data () => TextBufferApplyTagByNameMethodInfo
data () => TextBufferApplyTagMethodInfo
data () => TextBufferApplyTagSignalInfo
data () => TextBufferBackspaceMethodInfo
data () => TextBufferBeginUserActionMethodInfo
data () => TextBufferBeginUserActionSignalInfo
data () => TextBufferChangedSignalInfo
data () => TextBufferCopyClipboardMethodInfo
data () => TextBufferCopyTargetListPropertyInfo
data () => TextBufferCreateChildAnchorMethodInfo
data () => TextBufferCreateMarkMethodInfo
data () => TextBufferCursorPositionPropertyInfo
data () => TextBufferCutClipboardMethodInfo
data () => TextBufferDeleteInteractiveMethodInfo
data () => TextBufferDeleteMarkByNameMethodInfo
data () => TextBufferDeleteMarkMethodInfo
data () => TextBufferDeleteMethodInfo
data () => TextBufferDeleteRangeSignalInfo
data () => TextBufferDeleteSelectionMethodInfo
data () => TextBufferDeserializeGetCanCreateTagsMethodInfo
data () => TextBufferDeserializeMethodInfo
data () => TextBufferDeserializeSetCanCreateTagsMethodInfo
data () => TextBufferEndUserActionMethodInfo
data () => TextBufferEndUserActionSignalInfo
data () => TextBufferGetBoundsMethodInfo
data () => TextBufferGetCharCountMethodInfo
data () => TextBufferGetCopyTargetListMethodInfo
data () => TextBufferGetDeserializeFormatsMethodInfo
data () => TextBufferGetEndIterMethodInfo
data () => TextBufferGetHasSelectionMethodInfo
data () => TextBufferGetInsertMethodInfo
data () => TextBufferGetIterAtChildAnchorMethodInfo
data () => TextBufferGetIterAtLineIndexMethodInfo
data () => TextBufferGetIterAtLineMethodInfo
data () => TextBufferGetIterAtLineOffsetMethodInfo
data () => TextBufferGetIterAtMarkMethodInfo
data () => TextBufferGetIterAtOffsetMethodInfo
data () => TextBufferGetLineCountMethodInfo
data () => TextBufferGetMarkMethodInfo
data () => TextBufferGetModifiedMethodInfo
data () => TextBufferGetPasteTargetListMethodInfo
data () => TextBufferGetSelectionBoundMethodInfo
data () => TextBufferGetSelectionBoundsMethodInfo
data () => TextBufferGetSerializeFormatsMethodInfo
data () => TextBufferGetSliceMethodInfo
data () => TextBufferGetStartIterMethodInfo
data () => TextBufferGetTagTableMethodInfo
data () => TextBufferGetTextMethodInfo
data () => TextBufferHasSelectionPropertyInfo
data () => TextBufferInsertAtCursorMethodInfo
data () => TextBufferInsertChildAnchorMethodInfo
data () => TextBufferInsertChildAnchorSignalInfo
data () => TextBufferInsertInteractiveAtCursorMethodInfo
data () => TextBufferInsertInteractiveMethodInfo
data () => TextBufferInsertMarkupMethodInfo
data () => TextBufferInsertMethodInfo
data () => TextBufferInsertPixbufMethodInfo
data () => TextBufferInsertPixbufSignalInfo
data () => TextBufferInsertRangeInteractiveMethodInfo
data () => TextBufferInsertRangeMethodInfo
data () => TextBufferInsertTextSignalInfo
data () => TextBufferMarkDeletedSignalInfo
data () => TextBufferMarkSetSignalInfo
data () => TextBufferModifiedChangedSignalInfo
data () => TextBufferMoveMarkByNameMethodInfo
data () => TextBufferMoveMarkMethodInfo
data () => TextBufferPasteClipboardMethodInfo
data () => TextBufferPasteDoneSignalInfo
data () => TextBufferPasteTargetListPropertyInfo
data () => TextBufferPlaceCursorMethodInfo
data () => TextBufferRegisterDeserializeFormatMethodInfo
data () => TextBufferRegisterDeserializeTagsetMethodInfo
data () => TextBufferRegisterSerializeFormatMethodInfo
data () => TextBufferRegisterSerializeTagsetMethodInfo
data () => TextBufferRemoveAllTagsMethodInfo
data () => TextBufferRemoveSelectionClipboardMethodInfo
data () => TextBufferRemoveTagByNameMethodInfo
data () => TextBufferRemoveTagMethodInfo
data () => TextBufferRemoveTagSignalInfo
data () => TextBufferSelectRangeMethodInfo
data () => TextBufferSerializeMethodInfo
data () => TextBufferSetModifiedMethodInfo
data () => TextBufferSetTextMethodInfo
data () => TextBufferTagTablePropertyInfo
data () => TextBufferTextPropertyInfo
data () => TextBufferUnregisterDeserializeFormatMethodInfo
data () => TextBufferUnregisterSerializeFormatMethodInfo
type family ResolveTextCellAccessibleMethod (t :: Symbol) o
type family ResolveTextChildAnchorMethod (t :: Symbol) o
data () => TextChildAnchorGetDeletedMethodInfo
data () => TextChildAnchorGetWidgetsMethodInfo
type family ResolveTextMarkMethod (t :: Symbol) o
data () => TextMarkGetBufferMethodInfo
data () => TextMarkGetDeletedMethodInfo
data () => TextMarkGetLeftGravityMethodInfo
data () => TextMarkGetNameMethodInfo
data () => TextMarkGetVisibleMethodInfo
data () => TextMarkLeftGravityPropertyInfo
data () => TextMarkNamePropertyInfo
data () => TextMarkSetVisibleMethodInfo
type family ResolveTextTagMethod (t :: Symbol) o
data () => TextTagAccumulativeMarginPropertyInfo
data () => TextTagBackgroundFullHeightPropertyInfo
data () => TextTagBackgroundFullHeightSetPropertyInfo
data () => TextTagBackgroundGdkPropertyInfo
data () => TextTagBackgroundPropertyInfo
data () => TextTagBackgroundRgbaPropertyInfo
data () => TextTagBackgroundSetPropertyInfo
data () => TextTagChangedMethodInfo
data () => TextTagDirectionPropertyInfo
data () => TextTagEditablePropertyInfo
data () => TextTagEditableSetPropertyInfo
data () => TextTagEventMethodInfo
data () => TextTagEventSignalInfo
data () => TextTagFallbackPropertyInfo
data () => TextTagFallbackSetPropertyInfo
data () => TextTagFamilyPropertyInfo
data () => TextTagFamilySetPropertyInfo
data () => TextTagFontDescPropertyInfo
data () => TextTagFontFeaturesPropertyInfo
data () => TextTagFontFeaturesSetPropertyInfo
data () => TextTagFontPropertyInfo
data () => TextTagForegroundGdkPropertyInfo
data () => TextTagForegroundPropertyInfo
data () => TextTagForegroundRgbaPropertyInfo
data () => TextTagForegroundSetPropertyInfo
data () => TextTagGetPriorityMethodInfo
data () => TextTagIndentPropertyInfo
data () => TextTagIndentSetPropertyInfo
data () => TextTagInvisiblePropertyInfo
data () => TextTagInvisibleSetPropertyInfo
data () => TextTagJustificationPropertyInfo
data () => TextTagJustificationSetPropertyInfo
data () => TextTagLanguagePropertyInfo
data () => TextTagLanguageSetPropertyInfo
data () => TextTagLeftMarginPropertyInfo
data () => TextTagLeftMarginSetPropertyInfo
data () => TextTagLetterSpacingPropertyInfo
data () => TextTagLetterSpacingSetPropertyInfo
data () => TextTagNamePropertyInfo
data () => TextTagParagraphBackgroundGdkPropertyInfo
data () => TextTagParagraphBackgroundPropertyInfo
data () => TextTagParagraphBackgroundRgbaPropertyInfo
data () => TextTagParagraphBackgroundSetPropertyInfo
data () => TextTagPixelsAboveLinesPropertyInfo
data () => TextTagPixelsAboveLinesSetPropertyInfo
data () => TextTagPixelsBelowLinesPropertyInfo
data () => TextTagPixelsBelowLinesSetPropertyInfo
data () => TextTagPixelsInsideWrapPropertyInfo
data () => TextTagPixelsInsideWrapSetPropertyInfo
data () => TextTagRightMarginPropertyInfo
data () => TextTagRightMarginSetPropertyInfo
data () => TextTagRisePropertyInfo
data () => TextTagRiseSetPropertyInfo
data () => TextTagScalePropertyInfo
data () => TextTagScaleSetPropertyInfo
data () => TextTagSetPriorityMethodInfo
data () => TextTagSizePointsPropertyInfo
data () => TextTagSizePropertyInfo
data () => TextTagSizeSetPropertyInfo
data () => TextTagStretchPropertyInfo
data () => TextTagStretchSetPropertyInfo
data () => TextTagStrikethroughPropertyInfo
data () => TextTagStrikethroughRgbaPropertyInfo
data () => TextTagStrikethroughRgbaSetPropertyInfo
data () => TextTagStrikethroughSetPropertyInfo
data () => TextTagStylePropertyInfo
data () => TextTagStyleSetPropertyInfo
data () => TextTagTabsPropertyInfo
data () => TextTagTabsSetPropertyInfo
data () => TextTagUnderlinePropertyInfo
data () => TextTagUnderlineRgbaPropertyInfo
data () => TextTagUnderlineRgbaSetPropertyInfo
data () => TextTagUnderlineSetPropertyInfo
data () => TextTagVariantPropertyInfo
data () => TextTagVariantSetPropertyInfo
data () => TextTagWeightPropertyInfo
data () => TextTagWeightSetPropertyInfo
data () => TextTagWrapModePropertyInfo
data () => TextTagWrapModeSetPropertyInfo
type family ResolveTextTagTableMethod (t :: Symbol) o
data () => TextTagTableAddMethodInfo
data () => TextTagTableForeachMethodInfo
data () => TextTagTableGetSizeMethodInfo
data () => TextTagTableLookupMethodInfo
data () => TextTagTableRemoveMethodInfo
data () => TextTagTableTagAddedSignalInfo
data () => TextTagTableTagChangedSignalInfo
data () => TextTagTableTagRemovedSignalInfo
type family ResolveTextViewMethod (t :: Symbol) o
data () => TextViewAcceptsTabPropertyInfo
data () => TextViewAddChildAtAnchorMethodInfo
data () => TextViewAddChildInWindowMethodInfo
data () => TextViewBackspaceSignalInfo
data () => TextViewBackwardDisplayLineMethodInfo
data () => TextViewBackwardDisplayLineStartMethodInfo
data () => TextViewBottomMarginPropertyInfo
data () => TextViewBufferPropertyInfo
data () => TextViewBufferToWindowCoordsMethodInfo
data () => TextViewCopyClipboardSignalInfo
data () => TextViewCursorVisiblePropertyInfo
data () => TextViewCutClipboardSignalInfo
data () => TextViewDeleteFromCursorSignalInfo
data () => TextViewEditablePropertyInfo
data () => TextViewExtendSelectionSignalInfo
data () => TextViewForwardDisplayLineEndMethodInfo
data () => TextViewForwardDisplayLineMethodInfo
data () => TextViewGetAcceptsTabMethodInfo
data () => TextViewGetBorderWindowSizeMethodInfo
data () => TextViewGetBottomMarginMethodInfo
data () => TextViewGetBufferMethodInfo
data () => TextViewGetCursorLocationsMethodInfo
data () => TextViewGetCursorVisibleMethodInfo
data () => TextViewGetDefaultAttributesMethodInfo
data () => TextViewGetEditableMethodInfo
data () => TextViewGetHadjustmentMethodInfo
data () => TextViewGetIndentMethodInfo
data () => TextViewGetInputHintsMethodInfo
data () => TextViewGetInputPurposeMethodInfo
data () => TextViewGetIterAtLocationMethodInfo
data () => TextViewGetIterAtPositionMethodInfo
data () => TextViewGetIterLocationMethodInfo
data () => TextViewGetJustificationMethodInfo
data () => TextViewGetLeftMarginMethodInfo
data () => TextViewGetLineAtYMethodInfo
data () => TextViewGetLineYrangeMethodInfo
data () => TextViewGetMonospaceMethodInfo
data () => TextViewGetOverwriteMethodInfo
data () => TextViewGetPixelsAboveLinesMethodInfo
data () => TextViewGetPixelsBelowLinesMethodInfo
data () => TextViewGetPixelsInsideWrapMethodInfo
data () => TextViewGetRightMarginMethodInfo
data () => TextViewGetTabsMethodInfo
data () => TextViewGetTopMarginMethodInfo
data () => TextViewGetVadjustmentMethodInfo
data () => TextViewGetVisibleRectMethodInfo
data () => TextViewGetWindowMethodInfo
data () => TextViewGetWindowTypeMethodInfo
data () => TextViewGetWrapModeMethodInfo
data () => TextViewImContextFilterKeypressMethodInfo
data () => TextViewImModulePropertyInfo
data () => TextViewIndentPropertyInfo
data () => TextViewInputHintsPropertyInfo
data () => TextViewInputPurposePropertyInfo
data () => TextViewInsertAtCursorSignalInfo
data () => TextViewInsertEmojiSignalInfo
data () => TextViewJustificationPropertyInfo
data () => TextViewLeftMarginPropertyInfo
data () => TextViewMonospacePropertyInfo
data () => TextViewMoveChildMethodInfo
data () => TextViewMoveCursorSignalInfo
data () => TextViewMoveMarkOnscreenMethodInfo
data () => TextViewMoveViewportSignalInfo
data () => TextViewMoveVisuallyMethodInfo
data () => TextViewOverwritePropertyInfo
data () => TextViewPasteClipboardSignalInfo
data () => TextViewPixelsAboveLinesPropertyInfo
data () => TextViewPixelsBelowLinesPropertyInfo
data () => TextViewPixelsInsideWrapPropertyInfo
data () => TextViewPlaceCursorOnscreenMethodInfo
data () => TextViewPopulateAllPropertyInfo
data () => TextViewPopulatePopupSignalInfo
data () => TextViewPreeditChangedSignalInfo
data () => TextViewResetCursorBlinkMethodInfo
data () => TextViewResetImContextMethodInfo
data () => TextViewRightMarginPropertyInfo
data () => TextViewScrollMarkOnscreenMethodInfo
data () => TextViewScrollToIterMethodInfo
data () => TextViewScrollToMarkMethodInfo
data () => TextViewSelectAllSignalInfo
data () => TextViewSetAcceptsTabMethodInfo
data () => TextViewSetAnchorSignalInfo
data () => TextViewSetBorderWindowSizeMethodInfo
data () => TextViewSetBottomMarginMethodInfo
data () => TextViewSetBufferMethodInfo
data () => TextViewSetCursorVisibleMethodInfo
data () => TextViewSetEditableMethodInfo
data () => TextViewSetIndentMethodInfo
data () => TextViewSetInputHintsMethodInfo
data () => TextViewSetInputPurposeMethodInfo
data () => TextViewSetJustificationMethodInfo
data () => TextViewSetLeftMarginMethodInfo
data () => TextViewSetMonospaceMethodInfo
data () => TextViewSetOverwriteMethodInfo
data () => TextViewSetPixelsAboveLinesMethodInfo
data () => TextViewSetPixelsBelowLinesMethodInfo
data () => TextViewSetPixelsInsideWrapMethodInfo
data () => TextViewSetRightMarginMethodInfo
data () => TextViewSetTabsMethodInfo
data () => TextViewSetTopMarginMethodInfo
data () => TextViewSetWrapModeMethodInfo
data () => TextViewStartsDisplayLineMethodInfo
data () => TextViewTabsPropertyInfo
data () => TextViewToggleCursorVisibleSignalInfo
data () => TextViewToggleOverwriteSignalInfo
data () => TextViewTopMarginPropertyInfo
data () => TextViewWindowToBufferCoordsMethodInfo
data () => TextViewWrapModePropertyInfo
type family ResolveTextViewAccessibleMethod (t :: Symbol) o
type family ResolveThemingEngineMethod (t :: Symbol) o
data () => ThemingEngineGetBackgroundColorMethodInfo
data () => ThemingEngineGetBorderColorMethodInfo
data () => ThemingEngineGetBorderMethodInfo
data () => ThemingEngineGetColorMethodInfo
data () => ThemingEngineGetDirectionMethodInfo
data () => ThemingEngineGetFontMethodInfo
data () => ThemingEngineGetJunctionSidesMethodInfo
data () => ThemingEngineGetMarginMethodInfo
data () => ThemingEngineGetPaddingMethodInfo
data () => ThemingEngineGetPathMethodInfo
data () => ThemingEngineGetPropertyMethodInfo
data () => ThemingEngineGetScreenMethodInfo
data () => ThemingEngineGetStateMethodInfo
data () => ThemingEngineGetStylePropertyMethodInfo
data () => ThemingEngineHasClassMethodInfo
data () => ThemingEngineHasRegionMethodInfo
data () => ThemingEngineLookupColorMethodInfo
data () => ThemingEngineNamePropertyInfo
data () => ThemingEngineStateIsRunningMethodInfo
type family ResolveToggleActionMethod (t :: Symbol) o
data () => ToggleActionActivePropertyInfo
data () => ToggleActionDrawAsRadioPropertyInfo
data () => ToggleActionGetActiveMethodInfo
data () => ToggleActionGetDrawAsRadioMethodInfo
data () => ToggleActionSetActiveMethodInfo
data () => ToggleActionSetDrawAsRadioMethodInfo
data () => ToggleActionToggledMethodInfo
data () => ToggleActionToggledSignalInfo
type family ResolveToggleButtonMethod (t :: Symbol) o
data () => ToggleButtonActivePropertyInfo
data () => ToggleButtonDrawIndicatorPropertyInfo
data () => ToggleButtonGetActiveMethodInfo
data () => ToggleButtonGetInconsistentMethodInfo
data () => ToggleButtonGetModeMethodInfo
data () => ToggleButtonInconsistentPropertyInfo
data () => ToggleButtonSetActiveMethodInfo
data () => ToggleButtonSetInconsistentMethodInfo
data () => ToggleButtonSetModeMethodInfo
data () => ToggleButtonToggledMethodInfo
data () => ToggleButtonToggledSignalInfo
type family ResolveToggleButtonAccessibleMethod (t :: Symbol) o
type family ResolveToggleToolButtonMethod (t :: Symbol) o
data () => ToggleToolButtonActivePropertyInfo
data () => ToggleToolButtonGetActiveMethodInfo
data () => ToggleToolButtonSetActiveMethodInfo
data () => ToggleToolButtonToggledSignalInfo
type family ResolveToolButtonMethod (t :: Symbol) o
data () => ToolButtonClickedSignalInfo
data () => ToolButtonGetIconNameMethodInfo
data () => ToolButtonGetIconWidgetMethodInfo
data () => ToolButtonGetLabelMethodInfo
data () => ToolButtonGetLabelWidgetMethodInfo
data () => ToolButtonGetStockIdMethodInfo
data () => ToolButtonGetUseUnderlineMethodInfo
data () => ToolButtonIconNamePropertyInfo
data () => ToolButtonIconWidgetPropertyInfo
data () => ToolButtonLabelPropertyInfo
data () => ToolButtonLabelWidgetPropertyInfo
data () => ToolButtonSetIconNameMethodInfo
data () => ToolButtonSetIconWidgetMethodInfo
data () => ToolButtonSetLabelMethodInfo
data () => ToolButtonSetLabelWidgetMethodInfo
data () => ToolButtonSetStockIdMethodInfo
data () => ToolButtonSetUseUnderlineMethodInfo
data () => ToolButtonStockIdPropertyInfo
data () => ToolButtonUseUnderlinePropertyInfo
type family ResolveToolItemMethod (t :: Symbol) o
data () => ToolItemCreateMenuProxySignalInfo
data () => ToolItemGetEllipsizeModeMethodInfo
data () => ToolItemGetExpandMethodInfo
data () => ToolItemGetHomogeneousMethodInfo
data () => ToolItemGetIconSizeMethodInfo
data () => ToolItemGetIsImportantMethodInfo
data () => ToolItemGetOrientationMethodInfo
data () => ToolItemGetProxyMenuItemMethodInfo
data () => ToolItemGetReliefStyleMethodInfo
data () => ToolItemGetTextAlignmentMethodInfo
data () => ToolItemGetTextOrientationMethodInfo
data () => ToolItemGetTextSizeGroupMethodInfo
data () => ToolItemGetToolbarStyleMethodInfo
data () => ToolItemGetUseDragWindowMethodInfo
data () => ToolItemGetVisibleHorizontalMethodInfo
data () => ToolItemGetVisibleVerticalMethodInfo
data () => ToolItemIsImportantPropertyInfo
data () => ToolItemRebuildMenuMethodInfo
data () => ToolItemRetrieveProxyMenuItemMethodInfo
data () => ToolItemSetExpandMethodInfo
data () => ToolItemSetHomogeneousMethodInfo
data () => ToolItemSetIsImportantMethodInfo
data () => ToolItemSetProxyMenuItemMethodInfo
data () => ToolItemSetTooltipMarkupMethodInfo
data () => ToolItemSetTooltipTextMethodInfo
data () => ToolItemSetUseDragWindowMethodInfo
data () => ToolItemSetVisibleHorizontalMethodInfo
data () => ToolItemSetVisibleVerticalMethodInfo
data () => ToolItemToolbarReconfiguredMethodInfo
data () => ToolItemToolbarReconfiguredSignalInfo
data () => ToolItemVisibleHorizontalPropertyInfo
data () => ToolItemVisibleVerticalPropertyInfo
type family ResolveToolItemGroupMethod (t :: Symbol) o
data () => ToolItemGroupCollapsedPropertyInfo
data () => ToolItemGroupEllipsizePropertyInfo
data () => ToolItemGroupGetCollapsedMethodInfo
data () => ToolItemGroupGetDropItemMethodInfo
data () => ToolItemGroupGetEllipsizeMethodInfo
data () => ToolItemGroupGetHeaderReliefMethodInfo
data () => ToolItemGroupGetItemPositionMethodInfo
data () => ToolItemGroupGetLabelMethodInfo
data () => ToolItemGroupGetLabelWidgetMethodInfo
data () => ToolItemGroupGetNItemsMethodInfo
data () => ToolItemGroupGetNthItemMethodInfo
data () => ToolItemGroupHeaderReliefPropertyInfo
data () => ToolItemGroupInsertMethodInfo
data () => ToolItemGroupLabelPropertyInfo
data () => ToolItemGroupLabelWidgetPropertyInfo
data () => ToolItemGroupSetCollapsedMethodInfo
data () => ToolItemGroupSetEllipsizeMethodInfo
data () => ToolItemGroupSetHeaderReliefMethodInfo
data () => ToolItemGroupSetItemPositionMethodInfo
data () => ToolItemGroupSetLabelMethodInfo
data () => ToolItemGroupSetLabelWidgetMethodInfo
type family ResolveToolPaletteMethod (t :: Symbol) o
data () => ToolPaletteAddDragDestMethodInfo
data () => ToolPaletteGetDragItemMethodInfo
data () => ToolPaletteGetDropGroupMethodInfo
data () => ToolPaletteGetDropItemMethodInfo
data () => ToolPaletteGetExclusiveMethodInfo
data () => ToolPaletteGetExpandMethodInfo
data () => ToolPaletteGetGroupPositionMethodInfo
data () => ToolPaletteGetHadjustmentMethodInfo
data () => ToolPaletteGetIconSizeMethodInfo
data () => ToolPaletteGetStyleMethodInfo
data () => ToolPaletteGetVadjustmentMethodInfo
data () => ToolPaletteIconSizePropertyInfo
data () => ToolPaletteIconSizeSetPropertyInfo
data () => ToolPaletteSetDragSourceMethodInfo
data () => ToolPaletteSetExclusiveMethodInfo
data () => ToolPaletteSetExpandMethodInfo
data () => ToolPaletteSetGroupPositionMethodInfo
data () => ToolPaletteSetIconSizeMethodInfo
data () => ToolPaletteSetStyleMethodInfo
data () => ToolPaletteToolbarStylePropertyInfo
data () => ToolPaletteUnsetIconSizeMethodInfo
data () => ToolPaletteUnsetStyleMethodInfo
type family ResolveToolbarMethod (t :: Symbol) o
data () => ToolbarFocusHomeOrEndSignalInfo
data () => ToolbarGetDropIndexMethodInfo
data () => ToolbarGetIconSizeMethodInfo
data () => ToolbarGetItemIndexMethodInfo
data () => ToolbarGetNItemsMethodInfo
data () => ToolbarGetNthItemMethodInfo
data () => ToolbarGetReliefStyleMethodInfo
data () => ToolbarGetShowArrowMethodInfo
data () => ToolbarGetStyleMethodInfo
data () => ToolbarIconSizePropertyInfo
data () => ToolbarIconSizeSetPropertyInfo
data () => ToolbarInsertMethodInfo
data () => ToolbarOrientationChangedSignalInfo
data () => ToolbarPopupContextMenuSignalInfo
data () => ToolbarSetDropHighlightItemMethodInfo
data () => ToolbarSetIconSizeMethodInfo
data () => ToolbarSetShowArrowMethodInfo
data () => ToolbarSetStyleMethodInfo
data () => ToolbarShowArrowPropertyInfo
data () => ToolbarStyleChangedSignalInfo
data () => ToolbarToolbarStylePropertyInfo
data () => ToolbarUnsetIconSizeMethodInfo
data () => ToolbarUnsetStyleMethodInfo
type family ResolveTooltipMethod (t :: Symbol) o
data () => TooltipSetCustomMethodInfo
data () => TooltipSetIconFromGiconMethodInfo
data () => TooltipSetIconFromIconNameMethodInfo
data () => TooltipSetIconFromStockMethodInfo
data () => TooltipSetIconMethodInfo
data () => TooltipSetMarkupMethodInfo
data () => TooltipSetTextMethodInfo
data () => TooltipSetTipAreaMethodInfo
type family ResolveToplevelAccessibleMethod (t :: Symbol) o
data () => ToplevelAccessibleGetChildrenMethodInfo
type family ResolveTreeModelFilterMethod (t :: Symbol) o
data () => TreeModelFilterChildModelPropertyInfo
data () => TreeModelFilterClearCacheMethodInfo
data () => TreeModelFilterConvertChildIterToIterMethodInfo
data () => TreeModelFilterConvertChildPathToPathMethodInfo
data () => TreeModelFilterConvertIterToChildIterMethodInfo
data () => TreeModelFilterConvertPathToChildPathMethodInfo
data () => TreeModelFilterGetModelMethodInfo
data () => TreeModelFilterRefilterMethodInfo
data () => TreeModelFilterSetVisibleColumnMethodInfo
data () => TreeModelFilterSetVisibleFuncMethodInfo
data () => TreeModelFilterVirtualRootPropertyInfo
type family ResolveTreeModelSortMethod (t :: Symbol) o
data () => TreeModelSortClearCacheMethodInfo
data () => TreeModelSortConvertChildIterToIterMethodInfo
data () => TreeModelSortConvertChildPathToPathMethodInfo
data () => TreeModelSortConvertIterToChildIterMethodInfo
data () => TreeModelSortConvertPathToChildPathMethodInfo
data () => TreeModelSortGetModelMethodInfo
data () => TreeModelSortIterIsValidMethodInfo
data () => TreeModelSortModelPropertyInfo
data () => TreeModelSortResetDefaultSortFuncMethodInfo
type family ResolveTreeSelectionMethod (t :: Symbol) o
data () => TreeSelectionChangedSignalInfo
data () => TreeSelectionCountSelectedRowsMethodInfo
data () => TreeSelectionGetModeMethodInfo
data () => TreeSelectionGetSelectedMethodInfo
data () => TreeSelectionGetSelectedRowsMethodInfo
data () => TreeSelectionGetTreeViewMethodInfo
data () => TreeSelectionIterIsSelectedMethodInfo
data () => TreeSelectionModePropertyInfo
data () => TreeSelectionPathIsSelectedMethodInfo
data () => TreeSelectionSelectAllMethodInfo
data () => TreeSelectionSelectIterMethodInfo
data () => TreeSelectionSelectPathMethodInfo
data () => TreeSelectionSelectRangeMethodInfo
data () => TreeSelectionSelectedForeachMethodInfo
data () => TreeSelectionSetModeMethodInfo
data () => TreeSelectionSetSelectFunctionMethodInfo
data () => TreeSelectionUnselectAllMethodInfo
data () => TreeSelectionUnselectIterMethodInfo
data () => TreeSelectionUnselectPathMethodInfo
data () => TreeSelectionUnselectRangeMethodInfo
type family ResolveTreeStoreMethod (t :: Symbol) o
data () => TreeStoreAppendMethodInfo
data () => TreeStoreClearMethodInfo
data () => TreeStoreInsertAfterMethodInfo
data () => TreeStoreInsertBeforeMethodInfo
data () => TreeStoreInsertMethodInfo
data () => TreeStoreInsertWithValuesMethodInfo
data () => TreeStoreIsAncestorMethodInfo
data () => TreeStoreIterDepthMethodInfo
data () => TreeStoreIterIsValidMethodInfo
data () => TreeStoreMoveAfterMethodInfo
data () => TreeStoreMoveBeforeMethodInfo
data () => TreeStorePrependMethodInfo
data () => TreeStoreRemoveMethodInfo
data () => TreeStoreSetColumnTypesMethodInfo
data () => TreeStoreSetMethodInfo
data () => TreeStoreSetValueMethodInfo
data () => TreeStoreSwapMethodInfo
type family ResolveTreeViewMethod (t :: Symbol) o
data () => TreeViewActivateOnSingleClickPropertyInfo
data () => TreeViewAppendColumnMethodInfo
data () => TreeViewCollapseAllMethodInfo
data () => TreeViewCollapseRowMethodInfo
data () => TreeViewColumnsAutosizeMethodInfo
data () => TreeViewColumnsChangedSignalInfo
data () => TreeViewConvertBinWindowToTreeCoordsMethodInfo
data () => TreeViewConvertBinWindowToWidgetCoordsMethodInfo
data () => TreeViewConvertTreeToBinWindowCoordsMethodInfo
data () => TreeViewConvertTreeToWidgetCoordsMethodInfo
data () => TreeViewConvertWidgetToBinWindowCoordsMethodInfo
data () => TreeViewConvertWidgetToTreeCoordsMethodInfo
data () => TreeViewCreateRowDragIconMethodInfo
data () => TreeViewCursorChangedSignalInfo
data () => TreeViewEnableGridLinesPropertyInfo
data () => TreeViewEnableModelDragDestMethodInfo
data () => TreeViewEnableModelDragSourceMethodInfo
data () => TreeViewEnableSearchPropertyInfo
data () => TreeViewEnableTreeLinesPropertyInfo
data () => TreeViewExpandAllMethodInfo
data () => TreeViewExpandCollapseCursorRowSignalInfo
data () => TreeViewExpandRowMethodInfo
data () => TreeViewExpandToPathMethodInfo
data () => TreeViewExpanderColumnPropertyInfo
data () => TreeViewFixedHeightModePropertyInfo
data () => TreeViewGetActivateOnSingleClickMethodInfo
data () => TreeViewGetBackgroundAreaMethodInfo
data () => TreeViewGetBinWindowMethodInfo
data () => TreeViewGetCellAreaMethodInfo
data () => TreeViewGetColumnMethodInfo
data () => TreeViewGetColumnsMethodInfo
data () => TreeViewGetCursorMethodInfo
data () => TreeViewGetDestRowAtPosMethodInfo
data () => TreeViewGetDragDestRowMethodInfo
data () => TreeViewGetEnableSearchMethodInfo
data () => TreeViewGetEnableTreeLinesMethodInfo
data () => TreeViewGetExpanderColumnMethodInfo
data () => TreeViewGetFixedHeightModeMethodInfo
data () => TreeViewGetGridLinesMethodInfo
data () => TreeViewGetHadjustmentMethodInfo
data () => TreeViewGetHeadersClickableMethodInfo
data () => TreeViewGetHeadersVisibleMethodInfo
data () => TreeViewGetHoverExpandMethodInfo
data () => TreeViewGetHoverSelectionMethodInfo
data () => TreeViewGetLevelIndentationMethodInfo
data () => TreeViewGetModelMethodInfo
data () => TreeViewGetNColumnsMethodInfo
data () => TreeViewGetPathAtPosMethodInfo
data () => TreeViewGetReorderableMethodInfo
data () => TreeViewGetRubberBandingMethodInfo
data () => TreeViewGetRulesHintMethodInfo
data () => TreeViewGetSearchColumnMethodInfo
data () => TreeViewGetSearchEntryMethodInfo
data () => TreeViewGetSelectionMethodInfo
data () => TreeViewGetShowExpandersMethodInfo
data () => TreeViewGetTooltipColumnMethodInfo
data () => TreeViewGetTooltipContextMethodInfo
data () => TreeViewGetVadjustmentMethodInfo
data () => TreeViewGetVisibleRangeMethodInfo
data () => TreeViewGetVisibleRectMethodInfo
data () => TreeViewHeadersClickablePropertyInfo
data () => TreeViewHeadersVisiblePropertyInfo
data () => TreeViewHoverExpandPropertyInfo
data () => TreeViewHoverSelectionPropertyInfo
data () => TreeViewInsertColumnMethodInfo
data () => TreeViewInsertColumnWithDataFuncMethodInfo
data () => TreeViewIsBlankAtPosMethodInfo
data () => TreeViewIsRubberBandingActiveMethodInfo
data () => TreeViewLevelIndentationPropertyInfo
data () => TreeViewMapExpandedRowsMethodInfo
data () => TreeViewModelPropertyInfo
data () => TreeViewMoveColumnAfterMethodInfo
data () => TreeViewMoveCursorSignalInfo
data () => TreeViewRemoveColumnMethodInfo
data () => TreeViewReorderablePropertyInfo
data () => TreeViewRowActivatedMethodInfo
data () => TreeViewRowActivatedSignalInfo
data () => TreeViewRowCollapsedSignalInfo
data () => TreeViewRowExpandedMethodInfo
data () => TreeViewRowExpandedSignalInfo
data () => TreeViewRubberBandingPropertyInfo
data () => TreeViewRulesHintPropertyInfo
data () => TreeViewScrollToCellMethodInfo
data () => TreeViewScrollToPointMethodInfo
data () => TreeViewSearchColumnPropertyInfo
data () => TreeViewSelectAllSignalInfo
data () => TreeViewSelectCursorParentSignalInfo
data () => TreeViewSelectCursorRowSignalInfo
data () => TreeViewSetActivateOnSingleClickMethodInfo
data () => TreeViewSetColumnDragFunctionMethodInfo
data () => TreeViewSetCursorMethodInfo
data () => TreeViewSetCursorOnCellMethodInfo
data () => TreeViewSetDestroyCountFuncMethodInfo
data () => TreeViewSetDragDestRowMethodInfo
data () => TreeViewSetEnableSearchMethodInfo
data () => TreeViewSetEnableTreeLinesMethodInfo
data () => TreeViewSetExpanderColumnMethodInfo
data () => TreeViewSetFixedHeightModeMethodInfo
data () => TreeViewSetGridLinesMethodInfo
data () => TreeViewSetHadjustmentMethodInfo
data () => TreeViewSetHeadersClickableMethodInfo
data () => TreeViewSetHeadersVisibleMethodInfo
data () => TreeViewSetHoverExpandMethodInfo
data () => TreeViewSetHoverSelectionMethodInfo
data () => TreeViewSetLevelIndentationMethodInfo
data () => TreeViewSetModelMethodInfo
data () => TreeViewSetReorderableMethodInfo
data () => TreeViewSetRowSeparatorFuncMethodInfo
data () => TreeViewSetRubberBandingMethodInfo
data () => TreeViewSetRulesHintMethodInfo
data () => TreeViewSetSearchColumnMethodInfo
data () => TreeViewSetSearchEntryMethodInfo
data () => TreeViewSetSearchEqualFuncMethodInfo
data () => TreeViewSetSearchPositionFuncMethodInfo
data () => TreeViewSetShowExpandersMethodInfo
data () => TreeViewSetTooltipCellMethodInfo
data () => TreeViewSetTooltipColumnMethodInfo
data () => TreeViewSetTooltipRowMethodInfo
data () => TreeViewSetVadjustmentMethodInfo
data () => TreeViewShowExpandersPropertyInfo
data () => TreeViewStartInteractiveSearchSignalInfo
data () => TreeViewTestCollapseRowSignalInfo
data () => TreeViewTestExpandRowSignalInfo
data () => TreeViewToggleCursorRowSignalInfo
data () => TreeViewTooltipColumnPropertyInfo
data () => TreeViewUnselectAllSignalInfo
data () => TreeViewUnsetRowsDragDestMethodInfo
data () => TreeViewUnsetRowsDragSourceMethodInfo
type family ResolveTreeViewAccessibleMethod (t :: Symbol) o
type family ResolveTreeViewColumnMethod (t :: Symbol) o
data () => TreeViewColumnAddAttributeMethodInfo
data () => TreeViewColumnAlignmentPropertyInfo
data () => TreeViewColumnCellAreaPropertyInfo
data () => TreeViewColumnCellGetPositionMethodInfo
data () => TreeViewColumnCellGetSizeMethodInfo
data () => TreeViewColumnCellIsVisibleMethodInfo
data () => TreeViewColumnCellSetCellDataMethodInfo
data () => TreeViewColumnClearAttributesMethodInfo
data () => TreeViewColumnClearMethodInfo
data () => TreeViewColumnClickablePropertyInfo
data () => TreeViewColumnClickedMethodInfo
data () => TreeViewColumnClickedSignalInfo
data () => TreeViewColumnExpandPropertyInfo
data () => TreeViewColumnFixedWidthPropertyInfo
data () => TreeViewColumnFocusCellMethodInfo
data () => TreeViewColumnGetAlignmentMethodInfo
data () => TreeViewColumnGetButtonMethodInfo
data () => TreeViewColumnGetClickableMethodInfo
data () => TreeViewColumnGetExpandMethodInfo
data () => TreeViewColumnGetFixedWidthMethodInfo
data () => TreeViewColumnGetMaxWidthMethodInfo
data () => TreeViewColumnGetMinWidthMethodInfo
data () => TreeViewColumnGetReorderableMethodInfo
data () => TreeViewColumnGetResizableMethodInfo
data () => TreeViewColumnGetSizingMethodInfo
data () => TreeViewColumnGetSortColumnIdMethodInfo
data () => TreeViewColumnGetSortIndicatorMethodInfo
data () => TreeViewColumnGetSortOrderMethodInfo
data () => TreeViewColumnGetSpacingMethodInfo
data () => TreeViewColumnGetTitleMethodInfo
data () => TreeViewColumnGetTreeViewMethodInfo
data () => TreeViewColumnGetVisibleMethodInfo
data () => TreeViewColumnGetWidgetMethodInfo
data () => TreeViewColumnGetWidthMethodInfo
data () => TreeViewColumnGetXOffsetMethodInfo
data () => TreeViewColumnMaxWidthPropertyInfo
data () => TreeViewColumnMinWidthPropertyInfo
data () => TreeViewColumnPackEndMethodInfo
data () => TreeViewColumnPackStartMethodInfo
data () => TreeViewColumnQueueResizeMethodInfo
data () => TreeViewColumnReorderablePropertyInfo
data () => TreeViewColumnResizablePropertyInfo
data () => TreeViewColumnSetAlignmentMethodInfo
data () => TreeViewColumnSetCellDataFuncMethodInfo
data () => TreeViewColumnSetClickableMethodInfo
data () => TreeViewColumnSetExpandMethodInfo
data () => TreeViewColumnSetFixedWidthMethodInfo
data () => TreeViewColumnSetMaxWidthMethodInfo
data () => TreeViewColumnSetMinWidthMethodInfo
data () => TreeViewColumnSetReorderableMethodInfo
data () => TreeViewColumnSetResizableMethodInfo
data () => TreeViewColumnSetSizingMethodInfo
data () => TreeViewColumnSetSortColumnIdMethodInfo
data () => TreeViewColumnSetSortIndicatorMethodInfo
data () => TreeViewColumnSetSortOrderMethodInfo
data () => TreeViewColumnSetSpacingMethodInfo
data () => TreeViewColumnSetTitleMethodInfo
data () => TreeViewColumnSetVisibleMethodInfo
data () => TreeViewColumnSetWidgetMethodInfo
data () => TreeViewColumnSizingPropertyInfo
data () => TreeViewColumnSortColumnIdPropertyInfo
data () => TreeViewColumnSortIndicatorPropertyInfo
data () => TreeViewColumnSortOrderPropertyInfo
data () => TreeViewColumnSpacingPropertyInfo
data () => TreeViewColumnTitlePropertyInfo
data () => TreeViewColumnVisiblePropertyInfo
data () => TreeViewColumnWidgetPropertyInfo
data () => TreeViewColumnWidthPropertyInfo
data () => TreeViewColumnXOffsetPropertyInfo
type family ResolveUIManagerMethod (t :: Symbol) o
data () => UIManagerActionsChangedSignalInfo
data () => UIManagerAddTearoffsPropertyInfo
data () => UIManagerAddUiFromFileMethodInfo
data () => UIManagerAddUiFromResourceMethodInfo
data () => UIManagerAddUiFromStringMethodInfo
data () => UIManagerAddUiMethodInfo
data () => UIManagerAddWidgetSignalInfo
data () => UIManagerConnectProxySignalInfo
data () => UIManagerDisconnectProxySignalInfo
data () => UIManagerEnsureUpdateMethodInfo
data () => UIManagerGetAccelGroupMethodInfo
data () => UIManagerGetActionGroupsMethodInfo
data () => UIManagerGetActionMethodInfo
data () => UIManagerGetAddTearoffsMethodInfo
data () => UIManagerGetToplevelsMethodInfo
data () => UIManagerGetUiMethodInfo
data () => UIManagerGetWidgetMethodInfo
data () => UIManagerInsertActionGroupMethodInfo
data () => UIManagerNewMergeIdMethodInfo
data () => UIManagerPostActivateSignalInfo
data () => UIManagerPreActivateSignalInfo
data () => UIManagerRemoveActionGroupMethodInfo
data () => UIManagerRemoveUiMethodInfo
data () => UIManagerSetAddTearoffsMethodInfo
data () => UIManagerUiPropertyInfo
type family ResolveVBoxMethod (t :: Symbol) o
type family ResolveVButtonBoxMethod (t :: Symbol) o
type family ResolveVPanedMethod (t :: Symbol) o
type family ResolveVScaleMethod (t :: Symbol) o
type family ResolveVScrollbarMethod (t :: Symbol) o
type family ResolveVSeparatorMethod (t :: Symbol) o
type family ResolveViewportMethod (t :: Symbol) o
data () => ViewportGetBinWindowMethodInfo
data () => ViewportGetHadjustmentMethodInfo
data () => ViewportGetShadowTypeMethodInfo
data () => ViewportGetVadjustmentMethodInfo
data () => ViewportGetViewWindowMethodInfo
data () => ViewportSetHadjustmentMethodInfo
data () => ViewportSetShadowTypeMethodInfo
data () => ViewportSetVadjustmentMethodInfo
data () => ViewportShadowTypePropertyInfo
type family ResolveVolumeButtonMethod (t :: Symbol) o
data () => VolumeButtonUseSymbolicPropertyInfo
type family ResolveWidgetMethod (t :: Symbol) o
data () => WidgetAccelClosuresChangedSignalInfo
data () => WidgetActivateMethodInfo
data () => WidgetAddAcceleratorMethodInfo
data () => WidgetAddDeviceEventsMethodInfo
data () => WidgetAddEventsMethodInfo
data () => WidgetAddMnemonicLabelMethodInfo
data () => WidgetAddTickCallbackMethodInfo
data () => WidgetAppPaintablePropertyInfo
data () => WidgetButtonPressEventSignalInfo
data () => WidgetButtonReleaseEventSignalInfo
data () => WidgetCanActivateAccelMethodInfo
data () => WidgetCanActivateAccelSignalInfo
data () => WidgetCanDefaultPropertyInfo
data () => WidgetCanFocusPropertyInfo
data () => WidgetChildFocusMethodInfo
data () => WidgetChildNotifyMethodInfo
data () => WidgetChildNotifySignalInfo
data () => WidgetClassPathMethodInfo
data () => WidgetCompositeChildPropertyInfo
data () => WidgetCompositedChangedSignalInfo
data () => WidgetComputeExpandMethodInfo
data () => WidgetConfigureEventSignalInfo
data () => WidgetCreatePangoContextMethodInfo
data () => WidgetCreatePangoLayoutMethodInfo
data () => WidgetDamageEventSignalInfo
data () => WidgetDeleteEventSignalInfo
data () => WidgetDestroyEventSignalInfo
data () => WidgetDestroyMethodInfo
data () => WidgetDestroySignalInfo
data () => WidgetDestroyedMethodInfo
data () => WidgetDeviceIsShadowedMethodInfo
data () => WidgetDirectionChangedSignalInfo
data () => WidgetDoubleBufferedPropertyInfo
data () => WidgetDragBeginMethodInfo
data () => WidgetDragBeginSignalInfo
data () => WidgetDragBeginWithCoordinatesMethodInfo
data () => WidgetDragCheckThresholdMethodInfo
data () => WidgetDragDataDeleteSignalInfo
data () => WidgetDragDataGetSignalInfo
data () => WidgetDragDataReceivedSignalInfo
data () => WidgetDragDestAddImageTargetsMethodInfo
data () => WidgetDragDestAddTextTargetsMethodInfo
data () => WidgetDragDestAddUriTargetsMethodInfo
data () => WidgetDragDestFindTargetMethodInfo
data () => WidgetDragDestGetTargetListMethodInfo
data () => WidgetDragDestGetTrackMotionMethodInfo
data () => WidgetDragDestSetMethodInfo
data () => WidgetDragDestSetProxyMethodInfo
data () => WidgetDragDestSetTargetListMethodInfo
data () => WidgetDragDestSetTrackMotionMethodInfo
data () => WidgetDragDestUnsetMethodInfo
data () => WidgetDragDropSignalInfo
data () => WidgetDragEndSignalInfo
data () => WidgetDragFailedSignalInfo
data () => WidgetDragGetDataMethodInfo
data () => WidgetDragHighlightMethodInfo
data () => WidgetDragLeaveSignalInfo
data () => WidgetDragMotionSignalInfo
data () => WidgetDragSourceAddImageTargetsMethodInfo
data () => WidgetDragSourceAddTextTargetsMethodInfo
data () => WidgetDragSourceAddUriTargetsMethodInfo
data () => WidgetDragSourceGetTargetListMethodInfo
data () => WidgetDragSourceSetIconGiconMethodInfo
data () => WidgetDragSourceSetIconNameMethodInfo
data () => WidgetDragSourceSetIconPixbufMethodInfo
data () => WidgetDragSourceSetIconStockMethodInfo
data () => WidgetDragSourceSetMethodInfo
data () => WidgetDragSourceSetTargetListMethodInfo
data () => WidgetDragSourceUnsetMethodInfo
data () => WidgetDragUnhighlightMethodInfo
data () => WidgetDrawMethodInfo
data () => WidgetDrawSignalInfo
data () => WidgetEnsureStyleMethodInfo
data () => WidgetEnterNotifyEventSignalInfo
data () => WidgetErrorBellMethodInfo
data () => WidgetEventAfterSignalInfo
data () => WidgetEventMethodInfo
data () => WidgetEventSignalInfo
data () => WidgetEventsPropertyInfo
data () => WidgetExpandPropertyInfo
data () => WidgetFocusInEventSignalInfo
data () => WidgetFocusOnClickPropertyInfo
data () => WidgetFocusOutEventSignalInfo
data () => WidgetFocusSignalInfo
data () => WidgetFreezeChildNotifyMethodInfo
data () => WidgetGetAccessibleMethodInfo
data () => WidgetGetActionGroupMethodInfo
data () => WidgetGetAllocatedBaselineMethodInfo
data () => WidgetGetAllocatedHeightMethodInfo
data () => WidgetGetAllocatedSizeMethodInfo
data () => WidgetGetAllocatedWidthMethodInfo
data () => WidgetGetAllocationMethodInfo
data () => WidgetGetAncestorMethodInfo
data () => WidgetGetAppPaintableMethodInfo
data () => WidgetGetCanDefaultMethodInfo
data () => WidgetGetCanFocusMethodInfo
data () => WidgetGetChildRequisitionMethodInfo
data () => WidgetGetChildVisibleMethodInfo
data () => WidgetGetClipMethodInfo
data () => WidgetGetClipboardMethodInfo
data () => WidgetGetCompositeNameMethodInfo
data () => WidgetGetDeviceEnabledMethodInfo
data () => WidgetGetDeviceEventsMethodInfo
data () => WidgetGetDirectionMethodInfo
data () => WidgetGetDisplayMethodInfo
data () => WidgetGetDoubleBufferedMethodInfo
data () => WidgetGetEventsMethodInfo
data () => WidgetGetFocusOnClickMethodInfo
data () => WidgetGetFontMapMethodInfo
data () => WidgetGetFontOptionsMethodInfo
data () => WidgetGetFrameClockMethodInfo
data () => WidgetGetHalignMethodInfo
data () => WidgetGetHasTooltipMethodInfo
data () => WidgetGetHasWindowMethodInfo
data () => WidgetGetHexpandMethodInfo
data () => WidgetGetHexpandSetMethodInfo
data () => WidgetGetMappedMethodInfo
data () => WidgetGetMarginBottomMethodInfo
data () => WidgetGetMarginEndMethodInfo
data () => WidgetGetMarginLeftMethodInfo
data () => WidgetGetMarginRightMethodInfo
data () => WidgetGetMarginStartMethodInfo
data () => WidgetGetMarginTopMethodInfo
data () => WidgetGetModifierMaskMethodInfo
data () => WidgetGetModifierStyleMethodInfo
data () => WidgetGetNameMethodInfo
data () => WidgetGetNoShowAllMethodInfo
data () => WidgetGetOpacityMethodInfo
data () => WidgetGetPangoContextMethodInfo
data () => WidgetGetParentMethodInfo
data () => WidgetGetParentWindowMethodInfo
data () => WidgetGetPathMethodInfo
data () => WidgetGetPointerMethodInfo
data () => WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
data () => WidgetGetPreferredHeightForWidthMethodInfo
data () => WidgetGetPreferredHeightMethodInfo
data () => WidgetGetPreferredSizeMethodInfo
data () => WidgetGetPreferredWidthForHeightMethodInfo
data () => WidgetGetPreferredWidthMethodInfo
data () => WidgetGetRealizedMethodInfo
data () => WidgetGetReceivesDefaultMethodInfo
data () => WidgetGetRequestModeMethodInfo
data () => WidgetGetRequisitionMethodInfo
data () => WidgetGetRootWindowMethodInfo
data () => WidgetGetScaleFactorMethodInfo
data () => WidgetGetScreenMethodInfo
data () => WidgetGetSensitiveMethodInfo
data () => WidgetGetSettingsMethodInfo
data () => WidgetGetSizeRequestMethodInfo
data () => WidgetGetStateFlagsMethodInfo
data () => WidgetGetStateMethodInfo
data () => WidgetGetStyleContextMethodInfo
data () => WidgetGetStyleMethodInfo
data () => WidgetGetSupportMultideviceMethodInfo
data () => WidgetGetTemplateChildMethodInfo
data () => WidgetGetTooltipMarkupMethodInfo
data () => WidgetGetTooltipTextMethodInfo
data () => WidgetGetTooltipWindowMethodInfo
data () => WidgetGetToplevelMethodInfo
data () => WidgetGetValignMethodInfo
data () => WidgetGetValignWithBaselineMethodInfo
data () => WidgetGetVexpandMethodInfo
data () => WidgetGetVexpandSetMethodInfo
data () => WidgetGetVisibleMethodInfo
data () => WidgetGetVisualMethodInfo
data () => WidgetGetWindowMethodInfo
data () => WidgetGrabAddMethodInfo
data () => WidgetGrabBrokenEventSignalInfo
data () => WidgetGrabDefaultMethodInfo
data () => WidgetGrabFocusMethodInfo
data () => WidgetGrabFocusSignalInfo
data () => WidgetGrabNotifySignalInfo
data () => WidgetGrabRemoveMethodInfo
data () => WidgetHalignPropertyInfo
data () => WidgetHasDefaultMethodInfo
data () => WidgetHasDefaultPropertyInfo
data () => WidgetHasFocusMethodInfo
data () => WidgetHasFocusPropertyInfo
data () => WidgetHasGrabMethodInfo
data () => WidgetHasRcStyleMethodInfo
data () => WidgetHasScreenMethodInfo
data () => WidgetHasTooltipPropertyInfo
data () => WidgetHasVisibleFocusMethodInfo
data () => WidgetHeightRequestPropertyInfo
data () => WidgetHexpandPropertyInfo
data () => WidgetHexpandSetPropertyInfo
data () => WidgetHideMethodInfo
data () => WidgetHideOnDeleteMethodInfo
data () => WidgetHideSignalInfo
data () => WidgetHierarchyChangedSignalInfo
data () => WidgetInDestructionMethodInfo
data () => WidgetInitTemplateMethodInfo
data () => WidgetInputShapeCombineRegionMethodInfo
data () => WidgetInsertActionGroupMethodInfo
data () => WidgetIntersectMethodInfo
data () => WidgetIsAncestorMethodInfo
data () => WidgetIsCompositedMethodInfo
data () => WidgetIsDrawableMethodInfo
data () => WidgetIsFocusMethodInfo
data () => WidgetIsFocusPropertyInfo
data () => WidgetIsSensitiveMethodInfo
data () => WidgetIsToplevelMethodInfo
data () => WidgetIsVisibleMethodInfo
data () => WidgetKeyPressEventSignalInfo
data () => WidgetKeyReleaseEventSignalInfo
data () => WidgetKeynavFailedMethodInfo
data () => WidgetKeynavFailedSignalInfo
data () => WidgetLeaveNotifyEventSignalInfo
data () => WidgetListAccelClosuresMethodInfo
data () => WidgetListActionPrefixesMethodInfo
data () => WidgetListMnemonicLabelsMethodInfo
data () => WidgetMapEventSignalInfo
data () => WidgetMapMethodInfo
data () => WidgetMapSignalInfo
data () => WidgetMarginBottomPropertyInfo
data () => WidgetMarginEndPropertyInfo
data () => WidgetMarginLeftPropertyInfo
data () => WidgetMarginPropertyInfo
data () => WidgetMarginRightPropertyInfo
data () => WidgetMarginStartPropertyInfo
data () => WidgetMarginTopPropertyInfo
data () => WidgetMnemonicActivateMethodInfo
data () => WidgetMnemonicActivateSignalInfo
data () => WidgetModifyBaseMethodInfo
data () => WidgetModifyBgMethodInfo
data () => WidgetModifyCursorMethodInfo
data () => WidgetModifyFgMethodInfo
data () => WidgetModifyFontMethodInfo
data () => WidgetModifyStyleMethodInfo
data () => WidgetModifyTextMethodInfo
data () => WidgetMotionNotifyEventSignalInfo
data () => WidgetMoveFocusSignalInfo
data () => WidgetNamePropertyInfo
data () => WidgetNoShowAllPropertyInfo
data () => WidgetOpacityPropertyInfo
data () => WidgetOverrideBackgroundColorMethodInfo
data () => WidgetOverrideColorMethodInfo
data () => WidgetOverrideCursorMethodInfo
data () => WidgetOverrideFontMethodInfo
data () => WidgetOverrideSymbolicColorMethodInfo
data () => WidgetParentPropertyInfo
data () => WidgetParentSetSignalInfo
data () => WidgetPathMethodInfo
data () => WidgetPopupMenuSignalInfo
data () => WidgetPropertyNotifyEventSignalInfo
data () => WidgetProximityInEventSignalInfo
data () => WidgetProximityOutEventSignalInfo
data () => WidgetQueryTooltipSignalInfo
data () => WidgetQueueAllocateMethodInfo
data () => WidgetQueueComputeExpandMethodInfo
data () => WidgetQueueDrawAreaMethodInfo
data () => WidgetQueueDrawMethodInfo
data () => WidgetQueueDrawRegionMethodInfo
data () => WidgetQueueResizeMethodInfo
data () => WidgetQueueResizeNoRedrawMethodInfo
data () => WidgetRealizeMethodInfo
data () => WidgetRealizeSignalInfo
data () => WidgetReceivesDefaultPropertyInfo
data () => WidgetRegionIntersectMethodInfo
data () => WidgetRegisterWindowMethodInfo
data () => WidgetRemoveAcceleratorMethodInfo
data () => WidgetRemoveMnemonicLabelMethodInfo
data () => WidgetRemoveTickCallbackMethodInfo
data () => WidgetRenderIconMethodInfo
data () => WidgetRenderIconPixbufMethodInfo
data () => WidgetReparentMethodInfo
data () => WidgetResetRcStylesMethodInfo
data () => WidgetResetStyleMethodInfo
data () => WidgetScaleFactorPropertyInfo
data () => WidgetScreenChangedSignalInfo
data () => WidgetScrollEventSignalInfo
data () => WidgetSelectionClearEventSignalInfo
data () => WidgetSelectionGetSignalInfo
data () => WidgetSelectionNotifyEventSignalInfo
data () => WidgetSelectionReceivedSignalInfo
data () => WidgetSelectionRequestEventSignalInfo
data () => WidgetSendExposeMethodInfo
data () => WidgetSendFocusChangeMethodInfo
data () => WidgetSensitivePropertyInfo
data () => WidgetSetAccelPathMethodInfo
data () => WidgetSetAllocationMethodInfo
data () => WidgetSetAppPaintableMethodInfo
data () => WidgetSetCanDefaultMethodInfo
data () => WidgetSetCanFocusMethodInfo
data () => WidgetSetChildVisibleMethodInfo
data () => WidgetSetClipMethodInfo
data () => WidgetSetCompositeNameMethodInfo
data () => WidgetSetDeviceEnabledMethodInfo
data () => WidgetSetDeviceEventsMethodInfo
data () => WidgetSetDirectionMethodInfo
data () => WidgetSetDoubleBufferedMethodInfo
data () => WidgetSetEventsMethodInfo
data () => WidgetSetFocusOnClickMethodInfo
data () => WidgetSetFontMapMethodInfo
data () => WidgetSetFontOptionsMethodInfo
data () => WidgetSetHalignMethodInfo
data () => WidgetSetHasTooltipMethodInfo
data () => WidgetSetHasWindowMethodInfo
data () => WidgetSetHexpandMethodInfo
data () => WidgetSetHexpandSetMethodInfo
data () => WidgetSetMappedMethodInfo
data () => WidgetSetMarginBottomMethodInfo
data () => WidgetSetMarginEndMethodInfo
data () => WidgetSetMarginLeftMethodInfo
data () => WidgetSetMarginRightMethodInfo
data () => WidgetSetMarginStartMethodInfo
data () => WidgetSetMarginTopMethodInfo
data () => WidgetSetNameMethodInfo
data () => WidgetSetNoShowAllMethodInfo
data () => WidgetSetOpacityMethodInfo
data () => WidgetSetParentMethodInfo
data () => WidgetSetParentWindowMethodInfo
data () => WidgetSetRealizedMethodInfo
data () => WidgetSetReceivesDefaultMethodInfo
data () => WidgetSetRedrawOnAllocateMethodInfo
data () => WidgetSetSensitiveMethodInfo
data () => WidgetSetSizeRequestMethodInfo
data () => WidgetSetStateFlagsMethodInfo
data () => WidgetSetStateMethodInfo
data () => WidgetSetStyleMethodInfo
data () => WidgetSetSupportMultideviceMethodInfo
data () => WidgetSetTooltipMarkupMethodInfo
data () => WidgetSetTooltipTextMethodInfo
data () => WidgetSetTooltipWindowMethodInfo
data () => WidgetSetValignMethodInfo
data () => WidgetSetVexpandMethodInfo
data () => WidgetSetVexpandSetMethodInfo
data () => WidgetSetVisibleMethodInfo
data () => WidgetSetVisualMethodInfo
data () => WidgetSetWindowMethodInfo
data () => WidgetShapeCombineRegionMethodInfo
data () => WidgetShowAllMethodInfo
data () => WidgetShowHelpSignalInfo
data () => WidgetShowMethodInfo
data () => WidgetShowNowMethodInfo
data () => WidgetShowSignalInfo
data () => WidgetSizeAllocateMethodInfo
data () => WidgetSizeAllocateSignalInfo
data () => WidgetSizeAllocateWithBaselineMethodInfo
data () => WidgetSizeRequestMethodInfo
data () => WidgetStateChangedSignalInfo
data () => WidgetStateFlagsChangedSignalInfo
data () => WidgetStyleAttachMethodInfo
data () => WidgetStyleGetPropertyMethodInfo
data () => WidgetStylePropertyInfo
data () => WidgetStyleSetSignalInfo
data () => WidgetStyleUpdatedSignalInfo
data () => WidgetThawChildNotifyMethodInfo
data () => WidgetTooltipMarkupPropertyInfo
data () => WidgetTooltipTextPropertyInfo
data () => WidgetTouchEventSignalInfo
data () => WidgetTranslateCoordinatesMethodInfo
data () => WidgetTriggerTooltipQueryMethodInfo
data () => WidgetUnmapEventSignalInfo
data () => WidgetUnmapMethodInfo
data () => WidgetUnmapSignalInfo
data () => WidgetUnparentMethodInfo
data () => WidgetUnrealizeMethodInfo
data () => WidgetUnrealizeSignalInfo
data () => WidgetUnregisterWindowMethodInfo
data () => WidgetUnsetStateFlagsMethodInfo
data () => WidgetValignPropertyInfo
data () => WidgetVexpandPropertyInfo
data () => WidgetVexpandSetPropertyInfo
data () => WidgetVisibilityNotifyEventSignalInfo
data () => WidgetVisiblePropertyInfo
data () => WidgetWidthRequestPropertyInfo
data () => WidgetWindowPropertyInfo
data () => WidgetWindowStateEventSignalInfo
type family ResolveWidgetAccessibleMethod (t :: Symbol) o
type family ResolveWindowMethod (t :: Symbol) o
data () => WindowAcceptFocusPropertyInfo
data () => WindowActivateDefaultMethodInfo
data () => WindowActivateDefaultSignalInfo
data () => WindowActivateFocusMethodInfo
data () => WindowActivateFocusSignalInfo
data () => WindowActivateKeyMethodInfo
data () => WindowAddAccelGroupMethodInfo
data () => WindowAddMnemonicMethodInfo
data () => WindowApplicationPropertyInfo
data () => WindowAttachedToPropertyInfo
data () => WindowBeginMoveDragMethodInfo
data () => WindowBeginResizeDragMethodInfo
data () => WindowCloseMethodInfo
data () => WindowDecoratedPropertyInfo
data () => WindowDefaultHeightPropertyInfo
data () => WindowDefaultWidthPropertyInfo
data () => WindowDeiconifyMethodInfo
data () => WindowDeletablePropertyInfo
data () => WindowDestroyWithParentPropertyInfo
data () => WindowEnableDebuggingSignalInfo
data () => WindowFocusOnMapPropertyInfo
data () => WindowFocusVisiblePropertyInfo
data () => WindowFullscreenMethodInfo
data () => WindowFullscreenOnMonitorMethodInfo
data () => WindowGetAcceptFocusMethodInfo
data () => WindowGetApplicationMethodInfo
data () => WindowGetAttachedToMethodInfo
data () => WindowGetDecoratedMethodInfo
data () => WindowGetDefaultSizeMethodInfo
data () => WindowGetDefaultWidgetMethodInfo
data () => WindowGetDeletableMethodInfo
data () => WindowGetDestroyWithParentMethodInfo
data () => WindowGetFocusMethodInfo
data () => WindowGetFocusOnMapMethodInfo
data () => WindowGetFocusVisibleMethodInfo
data () => WindowGetGravityMethodInfo
data () => WindowGetGroupMethodInfo
data () => WindowGetHasResizeGripMethodInfo
data () => WindowGetHideTitlebarWhenMaximizedMethodInfo
data () => WindowGetIconListMethodInfo
data () => WindowGetIconMethodInfo
data () => WindowGetIconNameMethodInfo
data () => WindowGetMnemonicModifierMethodInfo
data () => WindowGetMnemonicsVisibleMethodInfo
data () => WindowGetModalMethodInfo
data () => WindowGetOpacityMethodInfo
data () => WindowGetPositionMethodInfo
data () => WindowGetResizableMethodInfo
data () => WindowGetResizeGripAreaMethodInfo
data () => WindowGetRoleMethodInfo
data () => WindowGetScreenMethodInfo
data () => WindowGetSizeMethodInfo
data () => WindowGetSkipPagerHintMethodInfo
data () => WindowGetSkipTaskbarHintMethodInfo
data () => WindowGetTitleMethodInfo
data () => WindowGetTitlebarMethodInfo
data () => WindowGetTransientForMethodInfo
data () => WindowGetTypeHintMethodInfo
data () => WindowGetUrgencyHintMethodInfo
data () => WindowGetWindowTypeMethodInfo
data () => WindowGravityPropertyInfo
data () => WindowHasGroupMethodInfo
data () => WindowHasResizeGripPropertyInfo
data () => WindowHasToplevelFocusMethodInfo
data () => WindowHasToplevelFocusPropertyInfo
data () => WindowHideTitlebarWhenMaximizedPropertyInfo
data () => WindowIconNamePropertyInfo
data () => WindowIconPropertyInfo
data () => WindowIconifyMethodInfo
data () => WindowIsActiveMethodInfo
data () => WindowIsActivePropertyInfo
data () => WindowIsMaximizedMethodInfo
data () => WindowIsMaximizedPropertyInfo
data () => WindowKeysChangedSignalInfo
data () => WindowMaximizeMethodInfo
data () => WindowMnemonicActivateMethodInfo
data () => WindowMnemonicsVisiblePropertyInfo
data () => WindowModalPropertyInfo
data () => WindowMoveMethodInfo
data () => WindowParseGeometryMethodInfo
data () => WindowPresentMethodInfo
data () => WindowPresentWithTimeMethodInfo
data () => WindowPropagateKeyEventMethodInfo
data () => WindowRemoveAccelGroupMethodInfo
data () => WindowRemoveMnemonicMethodInfo
data () => WindowReshowWithInitialSizeMethodInfo
data () => WindowResizablePropertyInfo
data () => WindowResizeGripIsVisibleMethodInfo
data () => WindowResizeGripVisiblePropertyInfo
data () => WindowResizeMethodInfo
data () => WindowResizeToGeometryMethodInfo
data () => WindowRolePropertyInfo
data () => WindowScreenPropertyInfo
data () => WindowSetAcceptFocusMethodInfo
data () => WindowSetApplicationMethodInfo
data () => WindowSetAttachedToMethodInfo
data () => WindowSetDecoratedMethodInfo
data () => WindowSetDefaultGeometryMethodInfo
data () => WindowSetDefaultMethodInfo
data () => WindowSetDefaultSizeMethodInfo
data () => WindowSetDeletableMethodInfo
data () => WindowSetDestroyWithParentMethodInfo
data () => WindowSetFocusMethodInfo
data () => WindowSetFocusOnMapMethodInfo
data () => WindowSetFocusSignalInfo
data () => WindowSetFocusVisibleMethodInfo
data () => WindowSetGeometryHintsMethodInfo
data () => WindowSetGravityMethodInfo
data () => WindowSetHasResizeGripMethodInfo
data () => WindowSetHasUserRefCountMethodInfo
data () => WindowSetHideTitlebarWhenMaximizedMethodInfo
data () => WindowSetIconFromFileMethodInfo
data () => WindowSetIconListMethodInfo
data () => WindowSetIconMethodInfo
data () => WindowSetIconNameMethodInfo
data () => WindowSetKeepAboveMethodInfo
data () => WindowSetKeepBelowMethodInfo
data () => WindowSetMnemonicModifierMethodInfo
data () => WindowSetMnemonicsVisibleMethodInfo
data () => WindowSetModalMethodInfo
data () => WindowSetOpacityMethodInfo
data () => WindowSetPositionMethodInfo
data () => WindowSetResizableMethodInfo
data () => WindowSetRoleMethodInfo
data () => WindowSetScreenMethodInfo
data () => WindowSetSkipPagerHintMethodInfo
data () => WindowSetSkipTaskbarHintMethodInfo
data () => WindowSetStartupIdMethodInfo
data () => WindowSetTitleMethodInfo
data () => WindowSetTitlebarMethodInfo
data () => WindowSetTransientForMethodInfo
data () => WindowSetTypeHintMethodInfo
data () => WindowSetUrgencyHintMethodInfo
data () => WindowSetWmclassMethodInfo
data () => WindowSkipPagerHintPropertyInfo
data () => WindowSkipTaskbarHintPropertyInfo
data () => WindowStartupIdPropertyInfo
data () => WindowStickMethodInfo
data () => WindowTitlePropertyInfo
data () => WindowTransientForPropertyInfo
data () => WindowTypeHintPropertyInfo
data () => WindowTypePropertyInfo
data () => WindowUnfullscreenMethodInfo
data () => WindowUnmaximizeMethodInfo
data () => WindowUnstickMethodInfo
data () => WindowUrgencyHintPropertyInfo
data () => WindowWindowPositionPropertyInfo
type family ResolveWindowAccessibleMethod (t :: Symbol) o
type family ResolveWindowGroupMethod (t :: Symbol) o
data () => WindowGroupAddWindowMethodInfo
data () => WindowGroupGetCurrentDeviceGrabMethodInfo
data () => WindowGroupGetCurrentGrabMethodInfo
data () => WindowGroupListWindowsMethodInfo
data () => WindowGroupRemoveWindowMethodInfo
type family ResolveAccelGroupEntryMethod (t :: Symbol) o
type family ResolveAccelKeyMethod (t :: Symbol) o
type family ResolveActionEntryMethod (t :: Symbol) o
type family ResolveActionableInterfaceMethod (t :: Symbol) o
type family ResolveBindingArgMethod (t :: Symbol) o
type family ResolveBindingEntryMethod (t :: Symbol) o
data () => BindingSetActivateMethodInfo
data () => BindingSetAddPathMethodInfo
type family ResolveBindingSetMethod (t :: Symbol) o
type family ResolveBindingSignalMethod (t :: Symbol) o
data () => BorderCopyMethodInfo
data () => BorderFreeMethodInfo
type family ResolveBorderMethod (t :: Symbol) o
data () => ContainerClassFindChildPropertyMethodInfo
data () => ContainerClassHandleBorderWidthMethodInfo
data () => ContainerClassInstallChildPropertyMethodInfo
type family ResolveContainerClassMethod (t :: Symbol) o
data () => CssSectionGetEndLineMethodInfo
data () => CssSectionGetEndPositionMethodInfo
data () => CssSectionGetFileMethodInfo
data () => CssSectionGetParentMethodInfo
data () => CssSectionGetSectionTypeMethodInfo
data () => CssSectionGetStartLineMethodInfo
data () => CssSectionGetStartPositionMethodInfo
data () => CssSectionRefMethodInfo
data () => CssSectionUnrefMethodInfo
type family ResolveCssSectionMethod (t :: Symbol) o
type family ResolveFileFilterInfoMethod (t :: Symbol) o
type family ResolveFixedChildMethod (t :: Symbol) o
data () => GradientAddColorStopMethodInfo
data () => GradientRefMethodInfo
data () => GradientResolveForContextMethodInfo
data () => GradientResolveMethodInfo
data () => GradientToStringMethodInfo
data () => GradientUnrefMethodInfo
type family ResolveGradientMethod (t :: Symbol) o
type family ResolveIMContextInfoMethod (t :: Symbol) o
data () => IconSetAddSourceMethodInfo
data () => IconSetCopyMethodInfo
data () => IconSetGetSizesMethodInfo
data () => IconSetRefMethodInfo
data () => IconSetRenderIconMethodInfo
data () => IconSetRenderIconPixbufMethodInfo
data () => IconSetRenderIconSurfaceMethodInfo
data () => IconSetUnrefMethodInfo
type family ResolveIconSetMethod (t :: Symbol) o
data () => IconSourceCopyMethodInfo
data () => IconSourceFreeMethodInfo
data () => IconSourceGetDirectionMethodInfo
data () => IconSourceGetDirectionWildcardedMethodInfo
data () => IconSourceGetFilenameMethodInfo
data () => IconSourceGetIconNameMethodInfo
data () => IconSourceGetPixbufMethodInfo
data () => IconSourceGetSizeMethodInfo
data () => IconSourceGetSizeWildcardedMethodInfo
data () => IconSourceGetStateMethodInfo
data () => IconSourceGetStateWildcardedMethodInfo
data () => IconSourceSetDirectionMethodInfo
data () => IconSourceSetDirectionWildcardedMethodInfo
data () => IconSourceSetFilenameMethodInfo
data () => IconSourceSetIconNameMethodInfo
data () => IconSourceSetPixbufMethodInfo
data () => IconSourceSetSizeMethodInfo
data () => IconSourceSetSizeWildcardedMethodInfo
data () => IconSourceSetStateMethodInfo
data () => IconSourceSetStateWildcardedMethodInfo
type family ResolveIconSourceMethod (t :: Symbol) o
type family ResolveLabelSelectionInfoMethod (t :: Symbol) o
type family ResolveMountOperationHandlerIface_Method (t :: Symbol) o
type family ResolveMountOperationHandlerProxyClass_Method (t :: Symbol) o
type family ResolveMountOperationHandlerProxy_Method (t :: Symbol) o
type family ResolveMountOperationHandlerSkeletonClass_Method (t :: Symbol) o
type family ResolveMountOperationHandlerSkeleton_Method (t :: Symbol) o
type family ResolveMountOperationHandler_Method (t :: Symbol) o
type family ResolvePadActionEntryMethod (t :: Symbol) o
type family ResolvePageRangeMethod (t :: Symbol) o
data () => PaperSizeCopyMethodInfo
data () => PaperSizeFreeMethodInfo
data () => PaperSizeGetDefaultBottomMarginMethodInfo
data () => PaperSizeGetDefaultLeftMarginMethodInfo
data () => PaperSizeGetDefaultRightMarginMethodInfo
data () => PaperSizeGetDefaultTopMarginMethodInfo
data () => PaperSizeGetDisplayNameMethodInfo
data () => PaperSizeGetHeightMethodInfo
data () => PaperSizeGetNameMethodInfo
data () => PaperSizeGetPpdNameMethodInfo
data () => PaperSizeGetWidthMethodInfo
data () => PaperSizeIsCustomMethodInfo
data () => PaperSizeIsEqualMethodInfo
data () => PaperSizeIsIppMethodInfo
data () => PaperSizeSetSizeMethodInfo
data () => PaperSizeToGvariantMethodInfo
data () => PaperSizeToKeyFileMethodInfo
type family ResolvePaperSizeMethod (t :: Symbol) o
type family ResolveRadioActionEntryMethod (t :: Symbol) o
type family ResolveRcContextMethod (t :: Symbol) o
type family ResolveRcPropertyMethod (t :: Symbol) o
type family ResolveRecentDataMethod (t :: Symbol) o
type family ResolveRecentFilterInfoMethod (t :: Symbol) o
data () => RecentInfoCreateAppInfoMethodInfo
data () => RecentInfoExistsMethodInfo
data () => RecentInfoGetAddedMethodInfo
data () => RecentInfoGetAgeMethodInfo
data () => RecentInfoGetApplicationInfoMethodInfo
data () => RecentInfoGetApplicationsMethodInfo
data () => RecentInfoGetDescriptionMethodInfo
data () => RecentInfoGetDisplayNameMethodInfo
data () => RecentInfoGetGiconMethodInfo
data () => RecentInfoGetGroupsMethodInfo
data () => RecentInfoGetIconMethodInfo
data () => RecentInfoGetMimeTypeMethodInfo
data () => RecentInfoGetModifiedMethodInfo
data () => RecentInfoGetPrivateHintMethodInfo
data () => RecentInfoGetShortNameMethodInfo
data () => RecentInfoGetUriDisplayMethodInfo
data () => RecentInfoGetUriMethodInfo
data () => RecentInfoGetVisitedMethodInfo
data () => RecentInfoHasApplicationMethodInfo
data () => RecentInfoHasGroupMethodInfo
data () => RecentInfoIsLocalMethodInfo
data () => RecentInfoLastApplicationMethodInfo
data () => RecentInfoMatchMethodInfo
data () => RecentInfoRefMethodInfo
data () => RecentInfoUnrefMethodInfo
type family ResolveRecentInfoMethod (t :: Symbol) o
type family ResolveRequestedSizeMethod (t :: Symbol) o
data () => RequisitionCopyMethodInfo
data () => RequisitionFreeMethodInfo
type family ResolveRequisitionMethod (t :: Symbol) o
type family ResolveSelectionDataMethod (t :: Symbol) o
data () => SelectionDataCopyMethodInfo
data () => SelectionDataFreeMethodInfo
data () => SelectionDataGetDataMethodInfo
data () => SelectionDataGetDataTypeMethodInfo
data () => SelectionDataGetDisplayMethodInfo
data () => SelectionDataGetFormatMethodInfo
data () => SelectionDataGetLengthMethodInfo
data () => SelectionDataGetPixbufMethodInfo
data () => SelectionDataGetSelectionMethodInfo
data () => SelectionDataGetTargetMethodInfo
data () => SelectionDataGetTargetsMethodInfo
data () => SelectionDataGetTextMethodInfo
data () => SelectionDataGetUrisMethodInfo
data () => SelectionDataSetMethodInfo
data () => SelectionDataSetPixbufMethodInfo
data () => SelectionDataSetTextMethodInfo
data () => SelectionDataSetUrisMethodInfo
data () => SelectionDataTargetsIncludeImageMethodInfo
data () => SelectionDataTargetsIncludeRichTextMethodInfo
data () => SelectionDataTargetsIncludeTextMethodInfo
data () => SelectionDataTargetsIncludeUriMethodInfo
type family ResolveSettingsValueMethod (t :: Symbol) o
type family ResolveStockItemMethod (t :: Symbol) o
data () => StockItemFreeMethodInfo
type family ResolveSymbolicColorMethod (t :: Symbol) o
data () => SymbolicColorRefMethodInfo
data () => SymbolicColorResolveMethodInfo
data () => SymbolicColorToStringMethodInfo
data () => SymbolicColorUnrefMethodInfo
type family ResolveTableChildMethod (t :: Symbol) o
type family ResolveTableRowColMethod (t :: Symbol) o
type family ResolveTargetEntryMethod (t :: Symbol) o
data () => TargetEntryCopyMethodInfo
data () => TargetEntryFreeMethodInfo
type family ResolveTargetListMethod (t :: Symbol) o
data () => TargetListAddImageTargetsMethodInfo
data () => TargetListAddMethodInfo
data () => TargetListAddRichTextTargetsMethodInfo
data () => TargetListAddTableMethodInfo
data () => TargetListAddTextTargetsMethodInfo
data () => TargetListAddUriTargetsMethodInfo
data () => TargetListFindMethodInfo
data () => TargetListRefMethodInfo
data () => TargetListRemoveMethodInfo
data () => TargetListUnrefMethodInfo
type family ResolveTargetPairMethod (t :: Symbol) o
type family ResolveTextAppearanceMethod (t :: Symbol) o
type family ResolveTextAttributesMethod (t :: Symbol) o
data () => TextAttributesCopyMethodInfo
data () => TextAttributesCopyValuesMethodInfo
data () => TextAttributesRefMethodInfo
data () => TextAttributesUnrefMethodInfo
type family ResolveTextBTreeMethod (t :: Symbol) o
type family ResolveTextIterMethod (t :: Symbol) o
data () => TextIterAssignMethodInfo
data () => TextIterBackwardCharMethodInfo
data () => TextIterBackwardCharsMethodInfo
data () => TextIterBackwardCursorPositionMethodInfo
data () => TextIterBackwardCursorPositionsMethodInfo
data () => TextIterBackwardFindCharMethodInfo
data () => TextIterBackwardLineMethodInfo
data () => TextIterBackwardLinesMethodInfo
data () => TextIterBackwardSearchMethodInfo
data () => TextIterBackwardSentenceStartMethodInfo
data () => TextIterBackwardSentenceStartsMethodInfo
data () => TextIterBackwardToTagToggleMethodInfo
data () => TextIterBackwardVisibleCursorPositionMethodInfo
data () => TextIterBackwardVisibleCursorPositionsMethodInfo
data () => TextIterBackwardVisibleLineMethodInfo
data () => TextIterBackwardVisibleLinesMethodInfo
data () => TextIterBackwardVisibleWordStartMethodInfo
data () => TextIterBackwardVisibleWordStartsMethodInfo
data () => TextIterBackwardWordStartMethodInfo
data () => TextIterBackwardWordStartsMethodInfo
data () => TextIterBeginsTagMethodInfo
data () => TextIterCanInsertMethodInfo
data () => TextIterCompareMethodInfo
data () => TextIterCopyMethodInfo
data () => TextIterEditableMethodInfo
data () => TextIterEndsLineMethodInfo
data () => TextIterEndsSentenceMethodInfo
data () => TextIterEndsTagMethodInfo
data () => TextIterEndsWordMethodInfo
data () => TextIterEqualMethodInfo
data () => TextIterForwardCharMethodInfo
data () => TextIterForwardCharsMethodInfo
data () => TextIterForwardCursorPositionMethodInfo
data () => TextIterForwardCursorPositionsMethodInfo
data () => TextIterForwardFindCharMethodInfo
data () => TextIterForwardLineMethodInfo
data () => TextIterForwardLinesMethodInfo
data () => TextIterForwardSearchMethodInfo
data () => TextIterForwardSentenceEndMethodInfo
data () => TextIterForwardSentenceEndsMethodInfo
data () => TextIterForwardToEndMethodInfo
data () => TextIterForwardToLineEndMethodInfo
data () => TextIterForwardToTagToggleMethodInfo
data () => TextIterForwardVisibleCursorPositionMethodInfo
data () => TextIterForwardVisibleCursorPositionsMethodInfo
data () => TextIterForwardVisibleLineMethodInfo
data () => TextIterForwardVisibleLinesMethodInfo
data () => TextIterForwardVisibleWordEndMethodInfo
data () => TextIterForwardVisibleWordEndsMethodInfo
data () => TextIterForwardWordEndMethodInfo
data () => TextIterForwardWordEndsMethodInfo
data () => TextIterFreeMethodInfo
data () => TextIterGetAttributesMethodInfo
data () => TextIterGetBufferMethodInfo
data () => TextIterGetBytesInLineMethodInfo
data () => TextIterGetCharMethodInfo
data () => TextIterGetCharsInLineMethodInfo
data () => TextIterGetChildAnchorMethodInfo
data () => TextIterGetLanguageMethodInfo
data () => TextIterGetLineIndexMethodInfo
data () => TextIterGetLineMethodInfo
data () => TextIterGetLineOffsetMethodInfo
data () => TextIterGetMarksMethodInfo
data () => TextIterGetOffsetMethodInfo
data () => TextIterGetPixbufMethodInfo
data () => TextIterGetSliceMethodInfo
data () => TextIterGetTagsMethodInfo
data () => TextIterGetTextMethodInfo
data () => TextIterGetToggledTagsMethodInfo
data () => TextIterGetVisibleLineIndexMethodInfo
data () => TextIterGetVisibleLineOffsetMethodInfo
data () => TextIterGetVisibleSliceMethodInfo
data () => TextIterGetVisibleTextMethodInfo
data () => TextIterHasTagMethodInfo
data () => TextIterInRangeMethodInfo
data () => TextIterInsideSentenceMethodInfo
data () => TextIterInsideWordMethodInfo
data () => TextIterIsCursorPositionMethodInfo
data () => TextIterIsEndMethodInfo
data () => TextIterIsStartMethodInfo
data () => TextIterOrderMethodInfo
data () => TextIterSetLineIndexMethodInfo
data () => TextIterSetLineMethodInfo
data () => TextIterSetLineOffsetMethodInfo
data () => TextIterSetOffsetMethodInfo
data () => TextIterSetVisibleLineIndexMethodInfo
data () => TextIterSetVisibleLineOffsetMethodInfo
data () => TextIterStartsLineMethodInfo
data () => TextIterStartsSentenceMethodInfo
data () => TextIterStartsTagMethodInfo
data () => TextIterStartsWordMethodInfo
data () => TextIterTogglesTagMethodInfo
type family ResolveThemeEngineMethod (t :: Symbol) o
type family ResolveToggleActionEntryMethod (t :: Symbol) o
type family ResolveTreeIterMethod (t :: Symbol) o
data () => TreeIterCopyMethodInfo
data () => TreeIterFreeMethodInfo
type family ResolveTreePathMethod (t :: Symbol) o
data () => TreePathAppendIndexMethodInfo
data () => TreePathCompareMethodInfo
data () => TreePathCopyMethodInfo
data () => TreePathDownMethodInfo
data () => TreePathFreeMethodInfo
data () => TreePathGetDepthMethodInfo
data () => TreePathGetIndicesMethodInfo
data () => TreePathIsAncestorMethodInfo
data () => TreePathIsDescendantMethodInfo
data () => TreePathNextMethodInfo
data () => TreePathPrependIndexMethodInfo
data () => TreePathPrevMethodInfo
data () => TreePathToStringMethodInfo
data () => TreePathUpMethodInfo
type family ResolveTreeRowReferenceMethod (t :: Symbol) o
data () => TreeRowReferenceCopyMethodInfo
data () => TreeRowReferenceFreeMethodInfo
data () => TreeRowReferenceGetModelMethodInfo
data () => TreeRowReferenceGetPathMethodInfo
data () => TreeRowReferenceValidMethodInfo
type family ResolveWidgetClassMethod (t :: Symbol) o
data () => WidgetClassBindTemplateCallbackFullMethodInfo
data () => WidgetClassBindTemplateChildFullMethodInfo
data () => WidgetClassFindStylePropertyMethodInfo
data () => WidgetClassGetCssNameMethodInfo
data () => WidgetClassInstallStylePropertyMethodInfo
data () => WidgetClassSetAccessibleRoleMethodInfo
data () => WidgetClassSetAccessibleTypeMethodInfo
data () => WidgetClassSetConnectFuncMethodInfo
data () => WidgetClassSetCssNameMethodInfo
data () => WidgetClassSetTemplateFromResourceMethodInfo
data () => WidgetClassSetTemplateMethodInfo
type family ResolveWidgetPathMethod (t :: Symbol) o
data () => WidgetPathAppendForWidgetMethodInfo
data () => WidgetPathAppendTypeMethodInfo
data () => WidgetPathAppendWithSiblingsMethodInfo
data () => WidgetPathCopyMethodInfo
data () => WidgetPathFreeMethodInfo
data () => WidgetPathGetObjectTypeMethodInfo
data () => WidgetPathHasParentMethodInfo
data () => WidgetPathIsTypeMethodInfo
data () => WidgetPathIterAddClassMethodInfo
data () => WidgetPathIterAddRegionMethodInfo
data () => WidgetPathIterClearClassesMethodInfo
data () => WidgetPathIterClearRegionsMethodInfo
data () => WidgetPathIterGetNameMethodInfo
data () => WidgetPathIterGetObjectNameMethodInfo
data () => WidgetPathIterGetObjectTypeMethodInfo
data () => WidgetPathIterGetSiblingIndexMethodInfo
data () => WidgetPathIterGetSiblingsMethodInfo
data () => WidgetPathIterGetStateMethodInfo
data () => WidgetPathIterHasClassMethodInfo
data () => WidgetPathIterHasNameMethodInfo
data () => WidgetPathIterHasQclassMethodInfo
data () => WidgetPathIterHasQnameMethodInfo
data () => WidgetPathIterHasQregionMethodInfo
data () => WidgetPathIterHasRegionMethodInfo
data () => WidgetPathIterListClassesMethodInfo
data () => WidgetPathIterListRegionsMethodInfo
data () => WidgetPathIterRemoveClassMethodInfo
data () => WidgetPathIterRemoveRegionMethodInfo
data () => WidgetPathIterSetNameMethodInfo
data () => WidgetPathIterSetObjectNameMethodInfo
data () => WidgetPathIterSetObjectTypeMethodInfo
data () => WidgetPathIterSetStateMethodInfo
data () => WidgetPathLengthMethodInfo
data () => WidgetPathPrependTypeMethodInfo
data () => WidgetPathRefMethodInfo
data () => WidgetPathToStringMethodInfo
data () => WidgetPathUnrefMethodInfo
type family ResolveWindowGeometryInfoMethod (t :: Symbol) o

-- | Like <a>getMajorVersion</a>, but from the headers used at application
--   compile time, rather than from the library linked against at
--   application run time.
pattern MAJOR_VERSION :: Int32

-- | Like <a>getMicroVersion</a>, but from the headers used at application
--   compile time, rather than from the library linked against at
--   application run time.
pattern MICRO_VERSION :: Int32

-- | Like <a>getMinorVersion</a>, but from the headers used at application
--   compile time, rather than from the library linked against at
--   application run time.
pattern MINOR_VERSION :: Int32

-- | The priority used for default style information that is used in the
--   absence of themes.
--   
--   Note that this is not very useful for providing default styling for
--   custom style classes - themes are likely to override styling provided
--   at this priority with catch-all <tt>* {...}</tt> rules.
pattern STYLE_PROVIDER_PRIORITY_FALLBACK :: Int32

-- | A priority that can be used when adding a <a>StyleProvider</a> for
--   application-specific style information.
pattern STYLE_PROVIDER_PRIORITY_APPLICATION :: Int32

-- | The “Open” item and icon.
pattern STOCK_OPEN :: Text

-- | The “OK” item and icon.
pattern STOCK_OK :: Text

-- | The “Apply” item and icon.
pattern STOCK_APPLY :: Text

-- | A property holding the rendered element’s border width in pixels as a
--   <a>Border</a>. The border is the intermediary spacing property of the
--   padding/border/margin series.
--   
--   <a>renderFrame</a> uses this property to find out the frame line
--   width, so <tt><i>GtkWidgets</i></tt> rendering frames may need to add
--   up this padding when requesting size
pattern STYLE_PROPERTY_BORDER_WIDTH :: Text

-- | A property holding the foreground color of rendered elements as a
--   <a>RGBA</a>.
pattern STYLE_PROPERTY_COLOR :: Text

-- | A property holding the rendered element’s margin as a <a>Border</a>.
--   The margin is defined as the spacing between the border of the element
--   and its surrounding elements. It is external to <a>Widget</a>'s size
--   allocations, and the most external spacing property of the
--   padding/border/margin series.
pattern STYLE_PROPERTY_MARGIN :: Text

-- | A property holding the rendered element’s padding as a <a>Border</a>.
--   The padding is defined as the spacing between the inner part of the
--   element border and its child. It’s the innermost spacing property of
--   the padding/border/margin series.
pattern STYLE_PROPERTY_PADDING :: Text

-- | The priority used for the style information from
--   <tt>XDG_CONFIG_HOME/gtk-3.0/gtk.css</tt>.
--   
--   You should not use priorities higher than this, to give the user the
--   last word.
pattern STYLE_PROVIDER_PRIORITY_USER :: Int32

-- | The “Quit” item and icon.
pattern STOCK_QUIT :: Text

-- | Constant to return from a signal handler for the
--   <a>SpinButton::input</a> signal in case of conversion failure.
pattern INPUT_ERROR :: Int32

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_COLLATE :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_DEFAULT_SOURCE :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_DITHER :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_DUPLEX :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_FINISHINGS :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_MEDIA_TYPE :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_N_COPIES :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_NUMBER_UP :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_NUMBER_UP_LAYOUT :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_ORIENTATION :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_OUTPUT_BIN :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_PAGE_RANGES :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_PAGE_SET :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_PAPER_HEIGHT :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_PAPER_FORMAT :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_PAPER_WIDTH :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_PRINT_PAGES :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_PRINTER :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_PRINTER_LPI :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_QUALITY :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_RESOLUTION :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_RESOLUTION_X :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_RESOLUTION_Y :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_REVERSE :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_SCALE :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_USE_COLOR :: Text

-- | The GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID can be used to make a
--   <a>TreeSortable</a> use the default sort function.
--   
--   See also <a>treeSortableSetSortColumnId</a>
pattern TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID :: Int32

-- | The GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID can be used to make a
--   <a>TreeSortable</a> use no sorting.
--   
--   See also <a>treeSortableSetSortColumnId</a>
pattern TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID :: Int32

-- | Like <a>getBinaryAge</a>, but from the headers used at application
--   compile time, rather than from the library linked against at
--   application run time.
pattern BINARY_AGE :: Int32

-- | Like <a>getInterfaceAge</a>, but from the headers used at application
--   compile time, rather than from the library linked against at
--   application run time.
pattern INTERFACE_AGE :: Int32

-- | The name used for the stock full offset included by <a>LevelBar</a>.
--   
--   <i>Since: 3.20</i>
pattern LEVEL_BAR_OFFSET_FULL :: Text

-- | The name used for the stock high offset included by <a>LevelBar</a>.
--   
--   <i>Since: 3.6</i>
pattern LEVEL_BAR_OFFSET_HIGH :: Text

-- | The name used for the stock low offset included by <a>LevelBar</a>.
--   
--   <i>Since: 3.6</i>
pattern LEVEL_BAR_OFFSET_LOW :: Text

-- | The maximum length of sequences in compose tables.
pattern MAX_COMPOSE_LEN :: Int32

-- | Name for the A3 paper size.
pattern PAPER_NAME_A3 :: Text

-- | Name for the A4 paper size.
pattern PAPER_NAME_A4 :: Text

-- | Name for the A5 paper size.
pattern PAPER_NAME_A5 :: Text

-- | Name for the B5 paper size.
pattern PAPER_NAME_B5 :: Text

-- | Name for the Executive paper size.
pattern PAPER_NAME_EXECUTIVE :: Text

-- | Name for the Legal paper size.
pattern PAPER_NAME_LEGAL :: Text

-- | Name for the Letter paper size.
pattern PAPER_NAME_LETTER :: Text

-- | <i>No description available in the introspection data.</i>
pattern PATH_PRIO_MASK :: Int32

-- | The key used by the “Print to file” printer to store the file name of
--   the output without the path to the directory and the file extension.
--   
--   <i>Since: 3.6</i>
pattern PRINT_SETTINGS_OUTPUT_BASENAME :: Text

-- | The key used by the “Print to file” printer to store the directory to
--   which the output should be written.
--   
--   <i>Since: 3.6</i>
pattern PRINT_SETTINGS_OUTPUT_DIR :: Text

-- | The key used by the “Print to file” printer to store the format of the
--   output. The supported values are “PS” and “PDF”.
pattern PRINT_SETTINGS_OUTPUT_FILE_FORMAT :: Text

-- | The key used by the “Print to file” printer to store the URI to which
--   the output should be written. GTK+ itself supports only “file://”
--   URIs.
pattern PRINT_SETTINGS_OUTPUT_URI :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_WIN32_DRIVER_EXTRA :: Text

-- | <i>No description available in the introspection data.</i>
pattern PRINT_SETTINGS_WIN32_DRIVER_VERSION :: Text

-- | Use this priority for functionality related to size allocation.
--   
--   It is used internally by GTK+ to compute the sizes of widgets. This
--   priority is higher than <a>PRIORITY_REDRAW</a> to avoid resizing a
--   widget which was just redrawn.
pattern PRIORITY_RESIZE :: Int32

-- | The “About” item.
--   
--   <i>Since: 2.6</i>
pattern STOCK_ABOUT :: Text

-- | The “Add” item and icon.
pattern STOCK_ADD :: Text

-- | The “Bold” item and icon.
pattern STOCK_BOLD :: Text

-- | The “Cancel” item and icon.
pattern STOCK_CANCEL :: Text

-- | The “Caps Lock Warning” icon.
--   
--   <i>Since: 2.16</i>
pattern STOCK_CAPS_LOCK_WARNING :: Text

-- | The “CD-Rom” item and icon.
pattern STOCK_CDROM :: Text

-- | The “Clear” item and icon.
pattern STOCK_CLEAR :: Text

-- | The “Close” item and icon.
pattern STOCK_CLOSE :: Text

-- | The “Color Picker” item and icon.
--   
--   <i>Since: 2.2</i>
pattern STOCK_COLOR_PICKER :: Text

-- | The “Connect” icon.
--   
--   <i>Since: 2.6</i>
pattern STOCK_CONNECT :: Text

-- | The “Convert” item and icon.
pattern STOCK_CONVERT :: Text

-- | The “Copy” item and icon.
pattern STOCK_COPY :: Text

-- | The “Cut” item and icon.
pattern STOCK_CUT :: Text

-- | The “Delete” item and icon.
pattern STOCK_DELETE :: Text

-- | The “Authentication” item and icon.
--   
--   <i>Since: 2.4</i>
pattern STOCK_DIALOG_AUTHENTICATION :: Text

-- | The “Error” item and icon.
pattern STOCK_DIALOG_ERROR :: Text

-- | The “Information” item and icon.
pattern STOCK_DIALOG_INFO :: Text

-- | The “Question” item and icon.
pattern STOCK_DIALOG_QUESTION :: Text

-- | The “Warning” item and icon.
pattern STOCK_DIALOG_WARNING :: Text

-- | The “Directory” icon.
--   
--   <i>Since: 2.6</i>
pattern STOCK_DIRECTORY :: Text

-- | The “Discard” item.
--   
--   <i>Since: 2.12</i>
pattern STOCK_DISCARD :: Text

-- | The “Disconnect” icon.
--   
--   <i>Since: 2.6</i>
pattern STOCK_DISCONNECT :: Text

-- | The “Drag-And-Drop” icon.
pattern STOCK_DND :: Text

-- | The “Drag-And-Drop multiple” icon.
pattern STOCK_DND_MULTIPLE :: Text

-- | The “Edit” item and icon.
--   
--   <i>Since: 2.6</i>
pattern STOCK_EDIT :: Text

-- | The “Execute” item and icon.
pattern STOCK_EXECUTE :: Text

-- | The “File” item and icon.
--   
--   Since 3.0, this item has a label, before it only had an icon.
--   
--   <i>Since: 2.6</i>
pattern STOCK_FILE :: Text

-- | The “Find” item and icon.
pattern STOCK_FIND :: Text

-- | The “Find and Replace” item and icon.
pattern STOCK_FIND_AND_REPLACE :: Text

-- | The “Floppy” item and icon.
pattern STOCK_FLOPPY :: Text

-- | The “Fullscreen” item and icon.
--   
--   <i>Since: 2.8</i>
pattern STOCK_FULLSCREEN :: Text

-- | The “Bottom” item and icon.
pattern STOCK_GOTO_BOTTOM :: Text

-- | The “First” item and icon. The icon has an RTL variant.
pattern STOCK_GOTO_FIRST :: Text

-- | The “Last” item and icon. The icon has an RTL variant.
pattern STOCK_GOTO_LAST :: Text

-- | The “Top” item and icon.
pattern STOCK_GOTO_TOP :: Text

-- | The “Back” item and icon. The icon has an RTL variant.
pattern STOCK_GO_BACK :: Text

-- | The “Down” item and icon.
pattern STOCK_GO_DOWN :: Text

-- | The “Forward” item and icon. The icon has an RTL variant.
pattern STOCK_GO_FORWARD :: Text

-- | The “Up” item and icon.
pattern STOCK_GO_UP :: Text

-- | The “Harddisk” item and icon.
--   
--   <i>Since: 2.4</i>
pattern STOCK_HARDDISK :: Text

-- | The “Help” item and icon.
pattern STOCK_HELP :: Text

-- | The “Home” item and icon.
pattern STOCK_HOME :: Text

-- | The “Indent” item and icon. The icon has an RTL variant.
--   
--   <i>Since: 2.4</i>
pattern STOCK_INDENT :: Text

-- | The “Index” item and icon.
pattern STOCK_INDEX :: Text

-- | The “Info” item and icon.
--   
--   <i>Since: 2.8</i>
pattern STOCK_INFO :: Text

-- | The “Italic” item and icon.
pattern STOCK_ITALIC :: Text

-- | The “Jump to” item and icon. The icon has an RTL variant.
pattern STOCK_JUMP_TO :: Text

-- | The “Center” item and icon.
pattern STOCK_JUSTIFY_CENTER :: Text

-- | The “Fill” item and icon.
pattern STOCK_JUSTIFY_FILL :: Text

-- | The “Left” item and icon.
pattern STOCK_JUSTIFY_LEFT :: Text

-- | The “Right” item and icon.
pattern STOCK_JUSTIFY_RIGHT :: Text

-- | The “Leave Fullscreen” item and icon.
--   
--   <i>Since: 2.8</i>
pattern STOCK_LEAVE_FULLSCREEN :: Text

-- | The “Media Forward” item and icon. The icon has an RTL variant.
--   
--   <i>Since: 2.6</i>
pattern STOCK_MEDIA_FORWARD :: Text

-- | The “Media Next” item and icon. The icon has an RTL variant.
--   
--   <i>Since: 2.6</i>
pattern STOCK_MEDIA_NEXT :: Text

-- | The “Media Pause” item and icon.
--   
--   <i>Since: 2.6</i>
pattern STOCK_MEDIA_PAUSE :: Text

-- | The “Media Play” item and icon. The icon has an RTL variant.
--   
--   <i>Since: 2.6</i>
pattern STOCK_MEDIA_PLAY :: Text

-- | The “Media Previous” item and icon. The icon has an RTL variant.
--   
--   <i>Since: 2.6</i>
pattern STOCK_MEDIA_PREVIOUS :: Text

-- | The “Media Record” item and icon.
--   
--   <i>Since: 2.6</i>
pattern STOCK_MEDIA_RECORD :: Text

-- | The “Media Rewind” item and icon. The icon has an RTL variant.
--   
--   <i>Since: 2.6</i>
pattern STOCK_MEDIA_REWIND :: Text

-- | The “Media Stop” item and icon.
--   
--   <i>Since: 2.6</i>
pattern STOCK_MEDIA_STOP :: Text

-- | The “Missing image” icon.
pattern STOCK_MISSING_IMAGE :: Text

-- | The “Network” item and icon.
--   
--   <i>Since: 2.4</i>
pattern STOCK_NETWORK :: Text

-- | The “New” item and icon.
pattern STOCK_NEW :: Text

-- | The “No” item and icon.
pattern STOCK_NO :: Text

-- | The “Landscape Orientation” item and icon.
--   
--   <i>Since: 2.10</i>
pattern STOCK_ORIENTATION_LANDSCAPE :: Text

-- | The “Portrait Orientation” item and icon.
--   
--   <i>Since: 2.10</i>
pattern STOCK_ORIENTATION_PORTRAIT :: Text

-- | The “Reverse Landscape Orientation” item and icon.
--   
--   <i>Since: 2.10</i>
pattern STOCK_ORIENTATION_REVERSE_LANDSCAPE :: Text

-- | The “Reverse Portrait Orientation” item and icon.
--   
--   <i>Since: 2.10</i>
pattern STOCK_ORIENTATION_REVERSE_PORTRAIT :: Text

-- | The “Page Setup” item and icon.
--   
--   <i>Since: 2.14</i>
pattern STOCK_PAGE_SETUP :: Text

-- | The “Paste” item and icon.
pattern STOCK_PASTE :: Text

-- | The “Preferences” item and icon.
pattern STOCK_PREFERENCES :: Text

-- | The “Print” item and icon.
pattern STOCK_PRINT :: Text

-- | The “Print Error” icon.
--   
--   <i>Since: 2.14</i>
pattern STOCK_PRINT_ERROR :: Text

-- | The “Print Paused” icon.
--   
--   <i>Since: 2.14</i>
pattern STOCK_PRINT_PAUSED :: Text

-- | The “Print Preview” item and icon.
pattern STOCK_PRINT_PREVIEW :: Text

-- | The “Print Report” icon.
--   
--   <i>Since: 2.14</i>
pattern STOCK_PRINT_REPORT :: Text

-- | The “Print Warning” icon.
--   
--   <i>Since: 2.14</i>
pattern STOCK_PRINT_WARNING :: Text

-- | The “Properties” item and icon.
pattern STOCK_PROPERTIES :: Text

-- | The “Redo” item and icon. The icon has an RTL variant.
pattern STOCK_REDO :: Text

-- | The “Refresh” item and icon.
pattern STOCK_REFRESH :: Text

-- | The “Remove” item and icon.
pattern STOCK_REMOVE :: Text

-- | The “Revert” item and icon. The icon has an RTL variant.
pattern STOCK_REVERT_TO_SAVED :: Text

-- | The “Save” item and icon.
pattern STOCK_SAVE :: Text

-- | The “Save As” item and icon.
pattern STOCK_SAVE_AS :: Text

-- | The “Select All” item and icon.
--   
--   <i>Since: 2.10</i>
pattern STOCK_SELECT_ALL :: Text

-- | The “Color” item and icon.
pattern STOCK_SELECT_COLOR :: Text

-- | The “Font” item and icon.
pattern STOCK_SELECT_FONT :: Text

-- | The “Ascending” item and icon.
pattern STOCK_SORT_ASCENDING :: Text

-- | The “Descending” item and icon.
pattern STOCK_SORT_DESCENDING :: Text

-- | The “Spell Check” item and icon.
pattern STOCK_SPELL_CHECK :: Text

-- | The “Stop” item and icon.
pattern STOCK_STOP :: Text

-- | The “Strikethrough” item and icon.
pattern STOCK_STRIKETHROUGH :: Text

-- | The “Undelete” item and icon. The icon has an RTL variant.
pattern STOCK_UNDELETE :: Text

-- | The “Underline” item and icon.
pattern STOCK_UNDERLINE :: Text

-- | The “Undo” item and icon. The icon has an RTL variant.
pattern STOCK_UNDO :: Text

-- | The “Unindent” item and icon. The icon has an RTL variant.
--   
--   <i>Since: 2.4</i>
pattern STOCK_UNINDENT :: Text

-- | The “Yes” item and icon.
pattern STOCK_YES :: Text

-- | The “Zoom 100%” item and icon.
pattern STOCK_ZOOM_100 :: Text

-- | The “Zoom to Fit” item and icon.
pattern STOCK_ZOOM_FIT :: Text

-- | The “Zoom In” item and icon.
pattern STOCK_ZOOM_IN :: Text

-- | The “Zoom Out” item and icon.
pattern STOCK_ZOOM_OUT :: Text

-- | A CSS class to match an accelerator.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_ACCELERATOR :: Text

-- | A CSS class used when rendering an arrow element.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_ARROW :: Text

-- | A CSS class to match the window background.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_BACKGROUND :: Text

-- | A CSS class to indicate an area at the bottom of a widget.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_BOTTOM :: Text

-- | A CSS class to match buttons.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_BUTTON :: Text

-- | A CSS class to match calendars.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_CALENDAR :: Text

-- | A CSS class to match content rendered in cell views.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_CELL :: Text

-- | A CSS class to match check boxes.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_CHECK :: Text

-- | A CSS class to match combobox entries.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_COMBOBOX_ENTRY :: Text

-- | A CSS class to match context menus.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_CONTEXT_MENU :: Text

-- | A CSS class that gets added to windows which have client-side
--   decorations.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.14</i>
pattern STYLE_CLASS_CSD :: Text

-- | A CSS class used when rendering a drag handle for text selection.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_CURSOR_HANDLE :: Text

-- | A CSS class to match the default widget.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_DEFAULT :: Text

-- | A CSS class used when an action (usually a button) is one that is
--   expected to remove or destroy something visible to the user.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.12</i>
pattern STYLE_CLASS_DESTRUCTIVE_ACTION :: Text

-- | A CSS class to match dimmed labels.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_DIM_LABEL :: Text

-- | A CSS class for a drag-and-drop indicator.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_DND :: Text

-- | A CSS class defining a dock area.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_DOCK :: Text

-- | A CSS class to match text entries.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_ENTRY :: Text

-- | A CSS class for an area displaying an error message, such as those in
--   infobars.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_ERROR :: Text

-- | A CSS class defining an expander, such as those in treeviews.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_EXPANDER :: Text

-- | A CSS class that is added when widgets that usually have a frame or
--   border (like buttons or entries) should appear without it.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.14</i>
pattern STYLE_CLASS_FLAT :: Text

-- | A CSS class defining a frame delimiting content, such as <a>Frame</a>
--   or the scrolled window frame around the scrollable area.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_FRAME :: Text

-- | A CSS class defining a resize grip.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_GRIP :: Text

-- | A CSS class to match a header element.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_HEADER :: Text

-- | A CSS class defining a highlighted area, such as headings in
--   assistants and calendars.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_HIGHLIGHT :: Text

-- | A CSS class for horizontally layered widgets.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_HORIZONTAL :: Text

-- | A CSS class defining an image, such as the icon in an entry.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_IMAGE :: Text

-- | A CSS class for an area displaying an informational message, such as
--   those in infobars.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_INFO :: Text

-- | A CSS class to match inline toolbars.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_INLINE_TOOLBAR :: Text

-- | A CSS class used when rendering a drag handle for the insertion cursor
--   position.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_INSERTION_CURSOR :: Text

-- | A CSS class to match labels.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.16</i>
pattern STYLE_CLASS_LABEL :: Text

-- | A CSS class to indicate an area at the left of a widget.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_LEFT :: Text

-- | A CSS class used when rendering a level indicator, such as a battery
--   charge level, or a password strength.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_LEVEL_BAR :: Text

-- | A CSS class to match a linked area, such as a box containing buttons
--   belonging to the same control.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_LINKED :: Text

-- | A CSS class to match lists.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_LIST :: Text

-- | A CSS class to match list rows.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_LIST_ROW :: Text

-- | A CSS class defining marks in a widget, such as in scales.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_MARK :: Text

-- | A CSS class to match menus.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_MENU :: Text

-- | A CSS class to menubars.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_MENUBAR :: Text

-- | A CSS class to match menu items.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_MENUITEM :: Text

-- | A CSS class that is added to message dialogs.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.14</i>
pattern STYLE_CLASS_MESSAGE_DIALOG :: Text

-- | A CSS class that is added to text view that should use a monospace
--   font.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.16</i>
pattern STYLE_CLASS_MONOSPACE :: Text

-- | A CSS class used when an element needs the user attention, for
--   instance a button in a stack switcher corresponding to a hidden page
--   that changed state.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.12</i>
pattern STYLE_CLASS_NEEDS_ATTENTION :: Text

-- | A CSS class defining a notebook.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_NOTEBOOK :: Text

-- | A CSS class used when rendering an OSD (On Screen Display) element, on
--   top of another container.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_OSD :: Text

-- | A CSS class that is added on the visual hints that happen when
--   scrolling is attempted past the limits of a scrollable area.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.14</i>
pattern STYLE_CLASS_OVERSHOOT :: Text

-- | A CSS class for a pane separator, such as those in <a>Paned</a>.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_PANE_SEPARATOR :: Text

-- | A CSS class that is added to areas that should look like paper.
--   
--   This is used in print previews and themes are encouraged to style it
--   as black text on white background.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.16</i>
pattern STYLE_CLASS_PAPER :: Text

-- | A CSS class that matches popovers.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.14</i>
pattern STYLE_CLASS_POPOVER :: Text

-- | A CSS class that is added to the toplevel windows used for menus.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.14</i>
pattern STYLE_CLASS_POPUP :: Text

-- | A CSS class to match primary toolbars.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_PRIMARY_TOOLBAR :: Text

-- | A CSS class to use when rendering activity as a progressbar.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_PROGRESSBAR :: Text

-- | A CSS class to use when rendering a pulse in an indeterminate progress
--   bar.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_PULSE :: Text

-- | A CSS class for an area displaying a question to the user, such as
--   those in infobars.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_QUESTION :: Text

-- | A CSS class to match radio buttons.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_RADIO :: Text

-- | A CSS class to match a raised control, such as a raised button on a
--   toolbar.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_RAISED :: Text

-- | A CSS class used to indicate a read-only state.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_READ_ONLY :: Text

-- | A CSS class to indicate an area at the right of a widget.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_RIGHT :: Text

-- | A CSS class to match the rubberband selection rectangle.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_RUBBERBAND :: Text

-- | A CSS class to match scale widgets.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_SCALE :: Text

-- | A CSS class to match scale widgets with marks attached, all the marks
--   are above for horizontal <a>Scale</a>. left for vertical <a>Scale</a>.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_SCALE_HAS_MARKS_ABOVE :: Text

-- | A CSS class to match scale widgets with marks attached, all the marks
--   are below for horizontal <a>Scale</a>, right for vertical
--   <a>Scale</a>.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_SCALE_HAS_MARKS_BELOW :: Text

-- | A CSS class to match scrollbars.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_SCROLLBAR :: Text

-- | A CSS class to match the junction area between an horizontal and
--   vertical scrollbar, when they’re both shown.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_SCROLLBARS_JUNCTION :: Text

-- | A CSS class for a separator.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_SEPARATOR :: Text

-- | A CSS class defining a sidebar, such as the left side in a file
--   chooser.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_SIDEBAR :: Text

-- | A CSS class to match sliders.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_SLIDER :: Text

-- | A CSS class defining an spinbutton.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_SPINBUTTON :: Text

-- | A CSS class to use when rendering activity as a “spinner”.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_SPINNER :: Text

-- | A CSS class to match statusbars.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.16</i>
pattern STYLE_CLASS_STATUSBAR :: Text

-- | A CSS class used for the subtitle label in a titlebar in a toplevel
--   window.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.14</i>
pattern STYLE_CLASS_SUBTITLE :: Text

-- | A CSS class used when an action (usually a button) is the primary
--   suggested action in a specific context.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.12</i>
pattern STYLE_CLASS_SUGGESTED_ACTION :: Text

-- | A CSS class used for the title label in a titlebar in a toplevel
--   window.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.14</i>
pattern STYLE_CLASS_TITLE :: Text

-- | A CSS class used when rendering a titlebar in a toplevel window.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_TITLEBAR :: Text

-- | A CSS class to match toolbars.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_TOOLBAR :: Text

-- | A CSS class to match tooltip windows.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_TOOLTIP :: Text

-- | A CSS class to indicate an area at the top of a widget.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_TOP :: Text

-- | A CSS class for touch selection popups on entries and text views.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.16</i>
pattern STYLE_CLASS_TOUCH_SELECTION :: Text

-- | A CSS class to match troughs, as in scrollbars and progressbars.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_TROUGH :: Text

-- | A CSS class that is added on the visual hints that happen where
--   content is 'scrolled off' and can be made visible by scrolling.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.16</i>
pattern STYLE_CLASS_UNDERSHOOT :: Text

-- | A CSS class for vertically layered widgets.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_VERTICAL :: Text

-- | A CSS class defining a view, such as iconviews or treeviews.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_VIEW :: Text

-- | A CSS class for an area displaying a warning message, such as those in
--   infobars.
--   
--   Refer to individual widget documentation for used style classes.
pattern STYLE_CLASS_WARNING :: Text

-- | A CSS class to indicate that a UI element should be 'wide'. Used by
--   <a>Paned</a>.
--   
--   Refer to individual widget documentation for used style classes.
--   
--   <i>Since: 3.16</i>
pattern STYLE_CLASS_WIDE :: Text

-- | A property holding the background color of rendered elements as a
--   <a>RGBA</a>.
pattern STYLE_PROPERTY_BACKGROUND_COLOR :: Text

-- | A property holding the element’s background as a <a>Pattern</a>.
pattern STYLE_PROPERTY_BACKGROUND_IMAGE :: Text

-- | A property holding the element’s border color as a <a>RGBA</a>.
pattern STYLE_PROPERTY_BORDER_COLOR :: Text

-- | A property holding the rendered element’s border radius in pixels as a
--   <tt><i>gint</i></tt>.
pattern STYLE_PROPERTY_BORDER_RADIUS :: Text

-- | A property holding the element’s border style as a <a>BorderStyle</a>.
pattern STYLE_PROPERTY_BORDER_STYLE :: Text

-- | A property holding the font properties used when rendering text as a
--   <a>FontDescription</a>.
pattern STYLE_PROPERTY_FONT :: Text

-- | The priority used for style information provided via <a>Settings</a>.
--   
--   This priority is higher than <a>STYLE_PROVIDER_PRIORITY_THEME</a> to
--   let settings override themes.
pattern STYLE_PROVIDER_PRIORITY_SETTINGS :: Int32

-- | The priority used for style information provided by themes.
pattern STYLE_PROVIDER_PRIORITY_THEME :: Int32

-- | A widget region name to define a treeview column.
pattern STYLE_REGION_COLUMN :: Text

-- | A widget region name to define a treeview column header.
pattern STYLE_REGION_COLUMN_HEADER :: Text

-- | A widget region name to define a treeview row.
pattern STYLE_REGION_ROW :: Text

-- | A widget region name to define a notebook tab.
pattern STYLE_REGION_TAB :: Text

-- | The priority at which the text view validates onscreen lines in an
--   idle job in the background.
pattern TEXT_VIEW_PRIORITY_VALIDATE :: Int32

-- | Runs the main loop until <a>mainQuit</a> is called.
--   
--   You can nest calls to <a>main</a>. In that case <a>mainQuit</a> will
--   make the innermost invocation of the main loop return.
main :: (HasCallStack, MonadIO m) => m ()

-- | Call this function before using any other GTK+ functions in your GUI
--   applications. It will initialize everything needed to operate the
--   toolkit and parses some standard command line options.
--   
--   Although you are expected to pass the <i><tt>argc</tt></i>,
--   <i><tt>argv</tt></i> parameters from <tt><i>main()</i></tt> to this
--   function, it is possible to pass <a>Nothing</a> if
--   <i><tt>argv</tt></i> is not available or commandline handling is not
--   required.
--   
--   <i><tt>argc</tt></i> and <i><tt>argv</tt></i> are adjusted accordingly
--   so your own code will never see those standard arguments.
--   
--   Note that there are some alternative ways to initialize GTK+: if you
--   are calling <a>parseArgs</a>, <a>initCheck</a>, <a>initWithArgs</a> or
--   <a>optionContextParse</a> with the option group returned by
--   <a>getOptionGroup</a>, you don’t have to call <a>init</a>.
--   
--   And if you are using <a>Application</a>, you don't have to call any of
--   the initialization functions either; the
--   <a>Application</a>::<tt><i>startup</i></tt> handler does it for you.
--   
--   This function will terminate your program if it was unable to
--   initialize the windowing system for some reason. If you want your
--   program to fall back to a textual interface you want to call
--   <a>initCheck</a> instead.
--   
--   Since 2.18, GTK+ calls <tt>signal (SIGPIPE, SIG_IGN)</tt> during
--   initialization, to ignore SIGPIPE signals, since these are almost
--   never wanted in graphical applications. If you do need to handle
--   SIGPIPE for some reason, reset the handler after <a>init</a>, but
--   notice that other libraries (e.g. libdbus or gvfs) might do similar
--   things.
init :: (HasCallStack, MonadIO m) => Maybe [Text] -> m (Maybe [Text])

-- | Get the value of an attribute for an object.
get :: forall info (attr :: Symbol) obj result m. (AttrGetC info obj attr result, MonadIO m) => obj -> AttrLabelProxy attr -> m result

-- | Connect a signal to a signal handler.
on :: forall object info m. (GObject object, MonadIO m, SignalInfo info) => object -> SignalProxy object info -> ((?self :: object) => HaskellCallbackType info) -> m SignalHandlerId

-- | Set a number of properties for some object.
set :: forall o m. MonadIO m => o -> [AttrOp o 'AttrSet] -> m ()

-- | Allocate a new instance of the given type, with the given attributes.
new :: (Constructible a tag, MonadIO m) => (ManagedPtr a -> a) -> [AttrOp a tag] -> m a

-- | Make a copy of a wrapped pointer using <tt>memcpy</tt> into a freshly
--   allocated memory region of the given size.
copyBytes :: (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)

-- | Returns the GTK+ debug flags.
--   
--   This function is intended for GTK+ modules that want to adjust their
--   debug output based on GTK+ debug flags.
getDebugFlags :: (HasCallStack, MonadIO m) => m Word32

-- | Catch all GErrors from a particular error domain. The handler function
--   should just deal with one error enumeration type. If you need to catch
--   errors from more than one error domain, use this function twice with
--   an appropriate handler functions for each.
--   
--   <pre>
--   catchGErrorJustDomain
--     loadImage
--     (\err message -&gt; case err of
--         PixbufErrorCorruptImage -&gt; ...
--         PixbufErrorInsufficientMemory -&gt; ...
--         PixbufErrorUnknownType -&gt; ...
--         _ -&gt; ...)
--   </pre>
catchGErrorJustDomain :: GErrorClass err => IO a -> (err -> GErrorMessage -> IO a) -> IO a

-- | A verson of <a>catchGErrorJustDomain</a> with the arguments swapped
--   around.
handleGErrorJustDomain :: GErrorClass err => (err -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Creates a new <a>Window</a>, which is a toplevel window that can
--   contain other widgets. Nearly always, the type of the window should be
--   <tt><i>GTK_WINDOW_TOPLEVEL</i></tt>. If you’re implementing something
--   like a popup menu from scratch (which is a bad idea, just use
--   <a>Menu</a>), you might use <tt><i>GTK_WINDOW_POPUP</i></tt>.
--   <tt><i>GTK_WINDOW_POPUP</i></tt> is not for dialogs, though in some
--   other toolkits dialogs are called “popups”. In GTK+,
--   <tt><i>GTK_WINDOW_POPUP</i></tt> means a pop-up menu or pop-up
--   tooltip. On X11, popup windows are not controlled by the [window
--   manager][gtk-X11-arch].
--   
--   If you simply want an undecorated window (no window borders), use
--   <a>windowSetDecorated</a>, don’t use <tt><i>GTK_WINDOW_POPUP</i></tt>.
--   
--   All top-level windows created by <a>windowNew</a> are stored in an
--   internal top-level window list. This list can be obtained from
--   <a>windowListToplevels</a>. Due to Gtk+ keeping a reference to the
--   window internally, <a>windowNew</a> does not return a reference to the
--   caller.
--   
--   To delete a <a>Window</a>, call <a>widgetDestroy</a>.
windowNew :: (HasCallStack, MonadIO m) => WindowType -> m Window

-- | Cast from one object type to another, checking that the cast is valid.
--   If it is not, we return <a>Nothing</a>. Usage:
--   
--   <pre>
--   maybeWidget &lt;- castTo Widget label
--   </pre>
castTo :: (HasCallStack, ManagedPtrNewtype o, TypedObject o, ManagedPtrNewtype o', TypedObject o', GObject o') => (ManagedPtr o' -> o') -> o -> IO (Maybe o')

-- | Create a <a>GValue</a> from the given Haskell value.
toGValue :: (IsGValue a, MonadIO m) => a -> m GValue

-- | Create a Haskell object out of the given <a>GValue</a>.
fromGValue :: (IsGValue a, MonadIO m) => GValue -> m a

-- | Connect a signal to a handler, running the handler after the default
--   one.
after :: forall object info m. (GObject object, MonadIO m, SignalInfo info) => object -> SignalProxy object info -> ((?self :: object) => HaskellCallbackType info) -> m SignalHandlerId

-- | Retrieves a snapshot of the contained widget in the form of a
--   <a>Surface</a>. If you need to keep this around over window resizes
--   then you should add a reference to it.
--   
--   <i>Since: 2.20</i>
offscreenWindowGetSurface :: (HasCallStack, MonadIO m, IsOffscreenWindow a) => a -> m (Maybe Surface)

-- | Request the windowing system to make <i><tt>window</tt></i> partially
--   transparent, with opacity 0 being fully transparent and 1 fully
--   opaque. (Values of the opacity parameter are clamped to the [0,1]
--   range.) On X11 this has any effect only on X screens with a
--   compositing manager running. See <a>widgetIsComposited</a>. On Windows
--   it should work always.
--   
--   Note that setting a window’s opacity after the window has been shown
--   causes it to flicker once on Windows.
--   
--   <i>Since: 2.12</i>
windowSetOpacity :: (HasCallStack, MonadIO m, IsWindow a) => a -> Double -> m ()

-- | Parses command line arguments, and initializes global attributes of
--   GTK+, but does not actually open a connection to a display. (See
--   <a>displayOpen</a>, <a>getDisplayArgName</a>)
--   
--   Any arguments used by GTK+ or GDK are removed from the array and
--   <i><tt>argc</tt></i> and <i><tt>argv</tt></i> are updated accordingly.
--   
--   There is no need to call this function explicitly if you are using
--   <a>init</a>, or <a>initCheck</a>.
--   
--   Note that many aspects of GTK+ require a display connection to
--   function, so this way of initializing GTK+ is really only useful for
--   specialized use cases.
parseArgs :: (HasCallStack, MonadIO m) => [Text] -> m (Bool, [Text])

-- | This function does the same work as <a>init</a> with only a single
--   change: It does not terminate the program if the commandline arguments
--   couldn’t be parsed or the windowing system can’t be initialized.
--   Instead it returns <a>False</a> on failure.
--   
--   This way the application can fall back to some other means of
--   communication with the user - for example a curses or command line
--   interface.
--   
--   Note that calling any GTK function or instantiating any GTK type after
--   this function returns <a>False</a> results in undefined behavior.
initCheck :: (HasCallStack, MonadIO m) => Maybe [Text] -> m (Bool, Maybe [Text])

-- | Cast to <a>Window</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toWindow :: (MonadIO m, IsWindow o) => o -> m Window

-- | Starts moving a window. This function is used if an application has
--   window movement grips. When GDK can support it, the window movement
--   will be done using the standard mechanism for the [window
--   manager][gtk-X11-arch] or windowing system. Otherwise, GDK will try to
--   emulate window movement, potentially not all that well, depending on
--   the windowing system.
windowBeginMoveDrag :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> Int32 -> Word32 -> m ()

-- | Starts resizing a window. This function is used if an application has
--   window resizing controls. When GDK can support it, the resize will be
--   done using the standard mechanism for the [window
--   manager][gtk-X11-arch] or windowing system. Otherwise, GDK will try to
--   emulate window resizing, potentially not all that well, depending on
--   the windowing system.
windowBeginResizeDrag :: (HasCallStack, MonadIO m, IsWindow a) => a -> WindowEdge -> Int32 -> Int32 -> Int32 -> Word32 -> m ()

-- | Asks to deiconify (i.e. unminimize) the specified
--   <i><tt>window</tt></i>. Note that you shouldn’t assume the window is
--   definitely deiconified afterward, because other entities (e.g. the
--   user or [window manager][gtk-X11-arch])) could iconify it again before
--   your code which assumes deiconification gets to run.
--   
--   You can track iconification via the “window-state-event” signal on
--   <a>Widget</a>.
windowDeiconify :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks to place <i><tt>window</tt></i> in the fullscreen state. Note
--   that you shouldn’t assume the window is definitely full screen
--   afterward, because other entities (e.g. the user or [window
--   manager][gtk-X11-arch]) could unfullscreen it again, and not all
--   window managers honor requests to fullscreen windows. But normally the
--   window will end up fullscreen. Just don’t write code that crashes if
--   not.
--   
--   You can track the fullscreen state via the “window-state-event” signal
--   on <a>Widget</a>.
--   
--   <i>Since: 2.2</i>
windowFullscreen :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks to place <i><tt>window</tt></i> in the fullscreen state. Note
--   that you shouldn't assume the window is definitely full screen
--   afterward.
--   
--   You can track the fullscreen state via the "window-state-event" signal
--   on <a>Widget</a>.
--   
--   <i>Since: 3.18</i>
windowFullscreenOnMonitor :: (HasCallStack, MonadIO m, IsWindow a, IsScreen b) => a -> b -> Int32 -> m ()

-- | Gets the value set by <a>windowSetAcceptFocus</a>.
--   
--   <i>Since: 2.4</i>
windowGetAcceptFocus :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Gets the value set by <a>windowSetFocusOnMap</a>.
--   
--   <i>Since: 2.6</i>
windowGetFocusOnMap :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns the group for <i><tt>window</tt></i> or the default group, if
--   <i><tt>window</tt></i> is <a>Nothing</a> or if <i><tt>window</tt></i>
--   does not have an explicit window group.
--   
--   <i>Since: 2.10</i>
windowGetGroup :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> m WindowGroup

-- | This function returns the position you need to pass to
--   <a>windowMove</a> to keep <i><tt>window</tt></i> in its current
--   position. This means that the meaning of the returned value varies
--   with window gravity. See <a>windowMove</a> for more details.
--   
--   The reliability of this function depends on the windowing system
--   currently in use. Some windowing systems, such as Wayland, do not
--   support a global coordinate system, and thus the position of the
--   window will always be (0, 0). Others, like X11, do not have a reliable
--   way to obtain the geometry of the decorations of a window if they are
--   provided by the window manager. Additionally, on X11, window manager
--   have been known to mismanage window gravity, which result in windows
--   moving even if you use the coordinates of the current position as
--   returned by this function.
--   
--   If you haven’t changed the window gravity, its gravity will be
--   <tt><i>GDK_GRAVITY_NORTH_WEST</i></tt>. This means that
--   <a>windowGetPosition</a> gets the position of the top-left corner of
--   the window manager frame for the window. <a>windowMove</a> sets the
--   position of this same top-left corner.
--   
--   If a window has gravity <tt><i>GDK_GRAVITY_STATIC</i></tt> the window
--   manager frame is not relevant, and thus <a>windowGetPosition</a> will
--   always produce accurate results. However you can’t use static gravity
--   to do things like place a window in a corner of the screen, because
--   static gravity ignores the window manager decorations.
--   
--   Ideally, this function should return appropriate values if the window
--   has client side decorations, assuming that the windowing system
--   supports global coordinates.
--   
--   In practice, saving the window position should not be left to
--   applications, as they lack enough knowledge of the windowing system
--   and the window manager state to effectively do so. The appropriate way
--   to implement saving the window position is to use a platform-specific
--   protocol, wherever that is available.
windowGetPosition :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Int32, Int32)

-- | Returns the <a>Screen</a> associated with <i><tt>window</tt></i>.
--   
--   <i>Since: 2.2</i>
windowGetScreen :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Screen

-- | Gets the type hint for this window. See <a>windowSetTypeHint</a>.
windowGetTypeHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> m WindowTypeHint

-- | Gets the type of the window. See <a>WindowType</a>.
--   
--   <i>Since: 2.20</i>
windowGetWindowType :: (HasCallStack, MonadIO m, IsWindow a) => a -> m WindowType

-- | Asks to iconify (i.e. minimize) the specified <i><tt>window</tt></i>.
--   Note that you shouldn’t assume the window is definitely iconified
--   afterward, because other entities (e.g. the user or [window
--   manager][gtk-X11-arch]) could deiconify it again, or there may not be
--   a window manager in which case iconification isn’t possible, etc. But
--   normally the window will end up iconified. Just don’t write code that
--   crashes if not.
--   
--   It’s permitted to call this function before showing a window, in which
--   case the window will be iconified before it ever appears onscreen.
--   
--   You can track iconification via the “window-state-event” signal on
--   <a>Widget</a>.
windowIconify :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks to maximize <i><tt>window</tt></i>, so that it becomes
--   full-screen. Note that you shouldn’t assume the window is definitely
--   maximized afterward, because other entities (e.g. the user or [window
--   manager][gtk-X11-arch]) could unmaximize it again, and not all window
--   managers support maximization. But normally the window will end up
--   maximized. Just don’t write code that crashes if not.
--   
--   It’s permitted to call this function before showing a window, in which
--   case the window will be maximized when it appears onscreen initially.
--   
--   You can track maximization via the “window-state-event” signal on
--   <a>Widget</a>, or by listening to notifications on the
--   <a>Window:isMaximized</a> property.
windowMaximize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks the [window manager][gtk-X11-arch] to move <i><tt>window</tt></i>
--   to the given position. Window managers are free to ignore this; most
--   window managers ignore requests for initial window positions (instead
--   using a user-defined placement algorithm) and honor requests after the
--   window has already been shown.
--   
--   Note: the position is the position of the gravity-determined reference
--   point for the window. The gravity determines two things: first, the
--   location of the reference point in root window coordinates; and
--   second, which point on the window is positioned at the reference
--   point.
--   
--   By default the gravity is <tt><i>GDK_GRAVITY_NORTH_WEST</i></tt>, so
--   the reference point is simply the <i><tt>x</tt></i>, <i><tt>y</tt></i>
--   supplied to <a>windowMove</a>. The top-left corner of the window
--   decorations (aka window frame or border) will be placed at
--   <i><tt>x</tt></i>, <i><tt>y</tt></i>. Therefore, to position a window
--   at the top left of the screen, you want to use the default gravity
--   (which is <tt><i>GDK_GRAVITY_NORTH_WEST</i></tt>) and move the window
--   to 0,0.
--   
--   To position a window at the bottom right corner of the screen, you
--   would set <tt><i>GDK_GRAVITY_SOUTH_EAST</i></tt>, which means that the
--   reference point is at <i><tt>x</tt></i> + the window width and
--   <i><tt>y</tt></i> + the window height, and the bottom-right corner of
--   the window border will be placed at that reference point. So, to place
--   a window in the bottom right corner you would first set gravity to
--   south east, then write: <tt>gtk_window_move (window, gdk_screen_width
--   () - window_width, gdk_screen_height () - window_height)</tt> (note
--   that this example does not take multi-head scenarios into account).
--   
--   The <a>Extended Window Manager Hints Specification</a> has a nice
--   table of gravities in the “implementation notes” section.
--   
--   The <a>windowGetPosition</a> documentation may also be relevant.
windowMove :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> m ()

-- | Resizes the window as if the user had done so, obeying geometry
--   constraints. The default geometry constraint is that windows may not
--   be smaller than their size request; to override this constraint, call
--   <a>widgetSetSizeRequest</a> to set the window's request to a smaller
--   value.
--   
--   If <a>windowResize</a> is called before showing a window for the first
--   time, it overrides any default size set with
--   <a>windowSetDefaultSize</a>.
--   
--   Windows may not be resized smaller than 1 by 1 pixels.
--   
--   When using client side decorations, GTK+ will do its best to adjust
--   the given size so that the resulting window size matches the requested
--   size without the title bar, borders and shadows added for the client
--   side decorations, but there is no guarantee that the result will be
--   totally accurate because these widgets added for client side
--   decorations depend on the theme and may not be realized or visible at
--   the time <a>windowResize</a> is issued.
--   
--   If the GtkWindow has a titlebar widget (see <a>windowSetTitlebar</a>),
--   then typically, <a>windowResize</a> will compensate for the height of
--   the titlebar widget only if the height is known when the resulting
--   GtkWindow configuration is issued. For example, if new widgets are
--   added after the GtkWindow configuration and cause the titlebar widget
--   to grow in height, this will result in a window content smaller that
--   specified by <a>windowResize</a> and not a larger window.
windowResize :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> m ()

-- | Windows may set a hint asking the desktop environment not to receive
--   the input focus. This function sets this hint.
--   
--   <i>Since: 2.4</i>
windowSetAcceptFocus :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Windows may set a hint asking the desktop environment not to receive
--   the input focus when the window is mapped. This function sets this
--   hint.
--   
--   <i>Since: 2.6</i>
windowSetFocusOnMap :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | This function sets up hints about how a window can be resized by the
--   user. You can set a minimum and maximum size; allowed resize
--   increments (e.g. for xterm, you can only resize by the size of a
--   character); aspect ratios; and more. See the <a>Geometry</a> struct.
windowSetGeometryHints :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> Maybe Geometry -> [WindowHints] -> m ()

-- | Sets up the icon representing a <a>Window</a>. The icon is used when
--   the window is minimized (also known as iconified). Some window
--   managers or desktop environments may also place it in the window
--   frame, or display it in other contexts. On others, the icon is not
--   used at all, so your mileage may vary.
--   
--   <a>windowSetIconList</a> allows you to pass in the same icon in
--   several hand-drawn sizes. The list should contain the natural sizes
--   your icon is available in; that is, don’t scale the image before
--   passing it to GTK+. Scaling is postponed until the last minute, when
--   the desired final size is known, to allow best quality.
--   
--   By passing several sizes, you may improve the final image quality of
--   the icon, by reducing or eliminating automatic image scaling.
--   
--   Recommended sizes to provide: 16x16, 32x32, 48x48 at minimum, and
--   larger images (64x64, 128x128) if you have them.
--   
--   See also <a>windowSetDefaultIconList</a> to set the icon for all
--   windows in your application in one go.
--   
--   Note that transient windows (those who have been set transient for
--   another window using <a>windowSetTransientFor</a>) will inherit their
--   icon from their transient parent. So there’s no need to explicitly set
--   the icon on transient windows.
windowSetIconList :: (HasCallStack, MonadIO m, IsWindow a, IsPixbuf b) => a -> [b] -> m ()

-- | Sets the icon for the window from a named themed icon. See the docs
--   for <a>IconTheme</a> for more details. On some platforms, the window
--   icon is not used at all.
--   
--   Note that this has nothing to do with the WM_ICON_NAME property which
--   is mentioned in the ICCCM.
--   
--   <i>Since: 2.6</i>
windowSetIconName :: (HasCallStack, MonadIO m, IsWindow a) => a -> Maybe Text -> m ()

-- | Asks to keep <i><tt>window</tt></i> above, so that it stays on top.
--   Note that you shouldn’t assume the window is definitely above
--   afterward, because other entities (e.g. the user or [window
--   manager][gtk-X11-arch]) could not keep it above, and not all window
--   managers support keeping windows above. But normally the window will
--   end kept above. Just don’t write code that crashes if not.
--   
--   It’s permitted to call this function before showing a window, in which
--   case the window will be kept above when it appears onscreen initially.
--   
--   You can track the above state via the “window-state-event” signal on
--   <a>Widget</a>.
--   
--   Note that, according to the <a>Extended Window Manager Hints
--   Specification</a>, the above state is mainly meant for user
--   preferences and should not be used by applications e.g. for drawing
--   attention to their dialogs.
--   
--   <i>Since: 2.4</i>
windowSetKeepAbove :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Asks to keep <i><tt>window</tt></i> below, so that it stays in bottom.
--   Note that you shouldn’t assume the window is definitely below
--   afterward, because other entities (e.g. the user or [window
--   manager][gtk-X11-arch]) could not keep it below, and not all window
--   managers support putting windows below. But normally the window will
--   be kept below. Just don’t write code that crashes if not.
--   
--   It’s permitted to call this function before showing a window, in which
--   case the window will be kept below when it appears onscreen initially.
--   
--   You can track the below state via the “window-state-event” signal on
--   <a>Widget</a>.
--   
--   Note that, according to the <a>Extended Window Manager Hints
--   Specification</a>, the above state is mainly meant for user
--   preferences and should not be used by applications e.g. for drawing
--   attention to their dialogs.
--   
--   <i>Since: 2.4</i>
windowSetKeepBelow :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | This function is only useful on X11, not with other GTK+ targets.
--   
--   In combination with the window title, the window role allows a [window
--   manager][gtk-X11-arch] to identify "the same" window when an
--   application is restarted. So for example you might set the “toolbox”
--   role on your app’s toolbox window, so that when the user restarts
--   their session, the window manager can put the toolbox back in the same
--   place.
--   
--   If a window already has a unique title, you don’t need to set the
--   role, since the WM can use the title to identify the window when
--   restoring the session.
windowSetRole :: (HasCallStack, MonadIO m, IsWindow a) => a -> Text -> m ()

-- | Windows may set a hint asking the desktop environment not to display
--   the window in the pager. This function sets this hint. (A "pager" is
--   any desktop navigation tool such as a workspace switcher that displays
--   a thumbnail representation of the windows on the screen.)
--   
--   <i>Since: 2.2</i>
windowSetSkipPagerHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Windows may set a hint asking the desktop environment not to display
--   the window in the task bar. This function sets this hint.
--   
--   <i>Since: 2.2</i>
windowSetSkipTaskbarHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Startup notification identifiers are used by desktop environment to
--   track application startup, to provide user feedback and other
--   features. This function changes the corresponding property on the
--   underlying GdkWindow. Normally, startup identifier is managed
--   automatically and you should only use this function in special cases
--   like transferring focus from other processes. You should use this
--   function before calling <a>windowPresent</a> or any equivalent
--   function generating a window map event.
--   
--   This function is only useful on X11, not with other GTK+ targets.
--   
--   <i>Since: 2.12</i>
windowSetStartupId :: (HasCallStack, MonadIO m, IsWindow a) => a -> Text -> m ()

-- | Sets the title of the <a>Window</a>. The title of a window will be
--   displayed in its title bar; on the X Window System, the title bar is
--   rendered by the [window manager][gtk-X11-arch], so exactly how the
--   title appears to users may vary according to a user’s exact
--   configuration. The title should help a user distinguish this window
--   from other windows they may have open. A good title might include the
--   application name and current document filename, for example.
windowSetTitle :: (HasCallStack, MonadIO m, IsWindow a) => a -> Text -> m ()

-- | Dialog windows should be set transient for the main application window
--   they were spawned from. This allows [window managers][gtk-X11-arch] to
--   e.g. keep the dialog on top of the main window, or center the dialog
--   over the main window. <tt><i>gtk_dialog_new_with_buttons()</i></tt>
--   and other convenience functions in GTK+ will sometimes call
--   <a>windowSetTransientFor</a> on your behalf.
--   
--   Passing <a>Nothing</a> for <i><tt>parent</tt></i> unsets the current
--   transient window.
--   
--   On Wayland, this function can also be used to attach a new
--   <tt><i>GTK_WINDOW_POPUP</i></tt> to a
--   <tt><i>GTK_WINDOW_TOPLEVEL</i></tt> parent already mapped on screen so
--   that the <tt><i>GTK_WINDOW_POPUP</i></tt> will be created as a
--   subsurface-based window <tt><i>GDK_WINDOW_SUBSURFACE</i></tt> which
--   can be positioned at will relatively to the
--   <tt><i>GTK_WINDOW_TOPLEVEL</i></tt> surface.
--   
--   On Windows, this function puts the child window on top of the parent,
--   much as the window manager would have done on X.
windowSetTransientFor :: (HasCallStack, MonadIO m, IsWindow a, IsWindow b) => a -> Maybe b -> m ()

-- | By setting the type hint for the window, you allow the window manager
--   to decorate and handle the window in a way which is suitable to the
--   function of the window in your application.
--   
--   This function should be called before the window becomes visible.
--   
--   <tt><i>gtk_dialog_new_with_buttons()</i></tt> and other convenience
--   functions in GTK+ will sometimes call <a>windowSetTypeHint</a> on your
--   behalf.
windowSetTypeHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> WindowTypeHint -> m ()

-- | Windows may set a hint asking the desktop environment to draw the
--   users attention to the window. This function sets this hint.
--   
--   <i>Since: 2.8</i>
windowSetUrgencyHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Asks to stick <i><tt>window</tt></i>, which means that it will appear
--   on all user desktops. Note that you shouldn’t assume the window is
--   definitely stuck afterward, because other entities (e.g. the user or
--   [window manager][gtk-X11-arch] could unstick it again, and some window
--   managers do not support sticking windows. But normally the window will
--   end up stuck. Just don't write code that crashes if not.
--   
--   It’s permitted to call this function before showing a window.
--   
--   You can track stickiness via the “window-state-event” signal on
--   <a>Widget</a>.
windowStick :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks to toggle off the fullscreen state for <i><tt>window</tt></i>.
--   Note that you shouldn’t assume the window is definitely not full
--   screen afterward, because other entities (e.g. the user or [window
--   manager][gtk-X11-arch]) could fullscreen it again, and not all window
--   managers honor requests to unfullscreen windows. But normally the
--   window will end up restored to its normal state. Just don’t write code
--   that crashes if not.
--   
--   You can track the fullscreen state via the “window-state-event” signal
--   on <a>Widget</a>.
--   
--   <i>Since: 2.2</i>
windowUnfullscreen :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks to unmaximize <i><tt>window</tt></i>. Note that you shouldn’t
--   assume the window is definitely unmaximized afterward, because other
--   entities (e.g. the user or [window manager][gtk-X11-arch]) could
--   maximize it again, and not all window managers honor requests to
--   unmaximize. But normally the window will end up unmaximized. Just
--   don’t write code that crashes if not.
--   
--   You can track maximization via the “window-state-event” signal on
--   <a>Widget</a>.
windowUnmaximize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks to unstick <i><tt>window</tt></i>, which means that it will
--   appear on only one of the user’s desktops. Note that you shouldn’t
--   assume the window is definitely unstuck afterward, because other
--   entities (e.g. the user or [window manager][gtk-X11-arch]) could stick
--   it again. But normally the window will end up unstuck. Just don’t
--   write code that crashes if not.
--   
--   You can track stickiness via the “window-state-event” signal on
--   <a>Widget</a>.
windowUnstick :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Claim ownership of a given selection for a particular widget, or, if
--   <i><tt>widget</tt></i> is <a>Nothing</a>, release ownership of the
--   selection.
--   
--   <i>Since: 2.2</i>
selectionOwnerSetForDisplay :: (HasCallStack, MonadIO m, IsDisplay a, IsWidget b) => a -> Maybe b -> Atom -> Word32 -> m Bool

-- | Claims ownership of a given selection for a particular widget, or, if
--   <i><tt>widget</tt></i> is <a>Nothing</a>, release ownership of the
--   selection.
selectionOwnerSet :: (HasCallStack, MonadIO m, IsWidget a) => Maybe a -> Atom -> Word32 -> m Bool

-- | Requests the contents of a selection. When received, a
--   “selection-received” signal will be generated.
selectionConvert :: (HasCallStack, MonadIO m, IsWidget a) => a -> Atom -> Atom -> Word32 -> m Bool

-- | Checks if any events are pending.
--   
--   This can be used to update the UI and invoke timeouts etc. while doing
--   some time intensive computation.
--   
--   <h2>Updating the UI during a long computation</h2>
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   // computation going on...
--   
--   while (gtk_events_pending ())
--     gtk_main_iteration ();
--   
--   // ...computation continued
--   </pre>
eventsPending :: (HasCallStack, MonadIO m) => m Bool

-- | Free the given <a>GSList</a>.
g_slist_free :: Ptr (GSList a) -> IO ()

-- | Free the given <a>GList</a>.
g_list_free :: Ptr (GList a) -> IO ()

-- | Get the name assigned to the given <a>GType</a>.
gtypeName :: GType -> IO String

-- | A convenient synonym for <tt>Nothing :: Maybe GParamSpec</tt>.
noGParamSpec :: Maybe GParamSpec

-- | Safe coercions to a parent class. For instance:
--   
--   <pre>
--   #show $ label `asA` Gtk.Widget
--   </pre>
asA :: (ManagedPtrNewtype a, ManagedPtrNewtype b, HasParentTypes b, IsDescendantOf a b) => b -> (ManagedPtr a -> a) -> a

-- | Thin wrapper over <a>newForeignPtr</a>.
newManagedPtr :: HasCallStack => Ptr a -> IO () -> IO (ManagedPtr a)

-- | Version of <a>newManagedPtr</a> taking a <a>FinalizerPtr</a> and a
--   corresponding <a>Ptr</a>, as in <a>newForeignPtr</a>.
newManagedPtr' :: HasCallStack => FinalizerPtr a -> Ptr a -> IO (ManagedPtr a)

-- | Thin wrapper over <a>newForeignPtr_</a>.
newManagedPtr_ :: Ptr a -> IO (ManagedPtr a)

-- | Do not run the finalizers upon garbage collection of the
--   <a>ManagedPtr</a>.
disownManagedPtr :: (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)

-- | Perform an IO action on the <a>Ptr</a> inside a managed pointer.
withManagedPtr :: (HasCallStack, ManagedPtrNewtype a) => a -> (Ptr a -> IO c) -> IO c

-- | Like <a>withManagedPtr</a>, but accepts a <a>Maybe</a> type. If the
--   passed value is <a>Nothing</a> the inner action will be executed with
--   a <a>nullPtr</a> argument.
maybeWithManagedPtr :: (HasCallStack, ManagedPtrNewtype a) => Maybe a -> (Ptr a -> IO c) -> IO c

-- | Perform an IO action taking a list of <a>Ptr</a> on a list of managed
--   pointers.
withManagedPtrList :: (HasCallStack, ManagedPtrNewtype a) => [a] -> ([Ptr a] -> IO c) -> IO c

-- | Perform the IO action with a transient managed pointer. The managed
--   pointer will be valid while calling the action, but will be disowned
--   as soon as the action finishes.
withTransient :: (HasCallStack, ManagedPtrNewtype a) => Ptr a -> (a -> IO b) -> IO b

-- | Return the <a>Ptr</a> in a given managed pointer. As the name says,
--   this is potentially unsafe: the given <a>Ptr</a> may only be used
--   <i>before</i> a call to <a>touchManagedPtr</a>. This function is of
--   most interest to the autogenerated bindings, for hand-written code
--   <a>withManagedPtr</a> is almost always a better choice.
unsafeManagedPtrGetPtr :: (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)

-- | Same as <a>unsafeManagedPtrGetPtr</a>, but is polymorphic on the
--   return type.
unsafeManagedPtrCastPtr :: (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)

-- | Ensure that the <a>Ptr</a> in the given managed pointer is still alive
--   (i.e. it has not been garbage collected by the runtime) at the point
--   that this is called.
touchManagedPtr :: ManagedPtrNewtype a => a -> IO ()

-- | Check whether the given object is an instance of the given type.
checkInstanceType :: (ManagedPtrNewtype o, TypedObject o) => o -> GType -> IO Bool

-- | Cast a typed object to a new type (without any assumption that both
--   types descend from <a>GObject</a>), assuming that the cast will
--   succeed. This function will call <a>error</a> if the cast is illegal.
unsafeCastTo :: (HasCallStack, ManagedPtrNewtype o, TypedObject o, ManagedPtrNewtype o', TypedObject o') => (ManagedPtr o' -> o') -> o -> IO o'

-- | Construct a Haskell wrapper for a <a>GObject</a>, increasing its
--   reference count, or taking ownership of the floating reference if
--   there is one.
newObject :: (HasCallStack, GObject a, GObject b) => (ManagedPtr a -> a) -> Ptr b -> IO a

-- | Perform the given IO action with a wrapped copy of the given ptr to a
--   GObject. Note that this increases the reference count of the wrapped
--   GObject, similarly to <a>newObject</a>.
withNewObject :: (HasCallStack, GObject o) => Ptr o -> (o -> IO b) -> IO b

-- | Same as <a>newObject</a>, but we steal ownership of the object.
wrapObject :: (HasCallStack, GObject a, GObject b) => (ManagedPtr a -> a) -> Ptr b -> IO a

-- | Unref the given <a>GObject</a> and disown it. Use this if you want to
--   manually release the memory associated to a given <a>GObject</a>
--   (assuming that no other reference to the underlying C object exists)
--   before the garbage collector does it. It is typically not safe to
--   access the <a>GObject</a> after calling this function.
releaseObject :: (HasCallStack, GObject a) => a -> IO ()

-- | Decrease the reference count of the given <a>GObject</a>. The memory
--   associated with the object may be released if the reference count
--   reaches 0.
unrefObject :: (HasCallStack, GObject a) => a -> IO ()

-- | Disown a GObject, that is, do not unref the associated foreign GObject
--   when the Haskell object gets garbage collected. Returns the pointer to
--   the underlying GObject.
disownObject :: (HasCallStack, GObject a) => a -> IO (Ptr b)

-- | Construct a Haskell wrapper for the given boxed object. We make a copy
--   of the object.
newBoxed :: (HasCallStack, GBoxed a) => (ManagedPtr a -> a) -> Ptr a -> IO a

-- | Like <a>newBoxed</a>, but we do not make a copy (we "steal" the passed
--   object, so now it is managed by the Haskell runtime).
wrapBoxed :: (HasCallStack, GBoxed a) => (ManagedPtr a -> a) -> Ptr a -> IO a

-- | Make a copy of the given boxed object.
copyBoxed :: (HasCallStack, GBoxed a) => a -> IO (Ptr a)

-- | Like <a>copyBoxed</a>, but acting directly on a pointer, instead of a
--   managed pointer.
copyBoxedPtr :: GBoxed a => Ptr a -> IO (Ptr a)

-- | Free the memory associated with a boxed object. Note that this disowns
--   the associated <a>ManagedPtr</a> via <a>disownManagedPtr</a>.
freeBoxed :: (HasCallStack, GBoxed a) => a -> IO ()

-- | Disown a boxed object, that is, do not free the associated foreign
--   GBoxed when the Haskell object gets garbage collected. Returns the
--   pointer to the underlying <a>GBoxed</a>.
disownBoxed :: (HasCallStack, GBoxed a) => a -> IO (Ptr a)

-- | Wrap a pointer, taking ownership of it.
wrapPtr :: (HasCallStack, BoxedPtr a) => (ManagedPtr a -> a) -> Ptr a -> IO a

-- | Wrap a pointer, making a copy of the data.
newPtr :: (HasCallStack, BoxedPtr a) => (ManagedPtr a -> a) -> Ptr a -> IO a
unrefGHashTable :: Ptr (GHashTable a b) -> IO ()
unrefGByteArray :: Ptr GByteArray -> IO ()
unrefPtrArray :: Ptr (GPtrArray a) -> IO ()
unrefGArray :: Ptr (GArray a) -> IO ()
gflagsToWord :: (Num b, IsGFlag a) => [a] -> b
wordToGFlags :: (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]

-- | Given a Haskell list of items, construct a GList with those values.
packGList :: [Ptr a] -> IO (Ptr (GList (Ptr a)))

-- | Given a GSList construct the corresponding Haskell list.
unpackGList :: Ptr (GList (Ptr a)) -> IO [Ptr a]

-- | Given a Haskell list of items, construct a GSList with those values.
packGSList :: [Ptr a] -> IO (Ptr (GSList (Ptr a)))

-- | Given a GSList construct the corresponding Haskell list.
unpackGSList :: Ptr (GSList (Ptr a)) -> IO [Ptr a]
packGArray :: Storable a => [a] -> IO (Ptr (GArray a))
unpackGArray :: Storable a => Ptr (GArray a) -> IO [a]
packGPtrArray :: [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
unpackGPtrArray :: Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
packGByteArray :: ByteString -> IO (Ptr GByteArray)
unpackGByteArray :: Ptr GByteArray -> IO ByteString
packGHashTable :: GHashFunc a -> GEqualFunc a -> Maybe (GDestroyNotify a) -> Maybe (GDestroyNotify b) -> [(PtrWrapped a, PtrWrapped b)] -> IO (Ptr (GHashTable a b))
unpackGHashTable :: Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
packByteString :: ByteString -> IO (Ptr Word8)
packZeroTerminatedByteString :: ByteString -> IO (Ptr Word8)
unpackByteStringWithLength :: Integral a => a -> Ptr Word8 -> IO ByteString
unpackZeroTerminatedByteString :: Ptr Word8 -> IO ByteString
packStorableArray :: Storable a => [a] -> IO (Ptr a)
packZeroTerminatedStorableArray :: (Num a, Storable a) => [a] -> IO (Ptr a)
unpackStorableArrayWithLength :: (Integral a, Storable b) => a -> Ptr b -> IO [b]
unpackZeroTerminatedStorableArray :: (Eq a, Num a, Storable a) => Ptr a -> IO [a]
packMapStorableArray :: forall a b. Storable b => (a -> b) -> [a] -> IO (Ptr b)
packMapZeroTerminatedStorableArray :: forall a b. (Num b, Storable b) => (a -> b) -> [a] -> IO (Ptr b)
unpackMapStorableArrayWithLength :: (Integral a, Storable b) => (b -> c) -> a -> Ptr b -> IO [c]
unpackMapZeroTerminatedStorableArray :: (Eq a, Num a, Storable a) => (a -> b) -> Ptr a -> IO [b]
packUTF8CArray :: [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray :: [Text] -> IO (Ptr CString)
unpackZeroTerminatedUTF8CArray :: HasCallStack => Ptr CString -> IO [Text]
unpackUTF8CArrayWithLength :: (HasCallStack, Integral a) => a -> Ptr CString -> IO [Text]
packFileNameArray :: [String] -> IO (Ptr CString)
packZeroTerminatedFileNameArray :: [String] -> IO (Ptr CString)
unpackZeroTerminatedFileNameArray :: HasCallStack => Ptr CString -> IO [String]
unpackFileNameArrayWithLength :: (HasCallStack, Integral a) => a -> Ptr CString -> IO [String]
stringToCString :: String -> IO CString
cstringToString :: HasCallStack => CString -> IO String

-- | Convert <a>Text</a> into a <a>CString</a>, using the GLib allocator.
textToCString :: Text -> IO CString
withTextCString :: Text -> (CString -> IO a) -> IO a
cstringToText :: HasCallStack => CString -> IO Text
byteStringToCString :: ByteString -> IO CString
cstringToByteString :: HasCallStack => CString -> IO ByteString
packPtrArray :: [Ptr a] -> IO (Ptr (Ptr a))
packZeroTerminatedPtrArray :: [Ptr a] -> IO (Ptr (Ptr a))
unpackPtrArrayWithLength :: Integral a => a -> Ptr (Ptr b) -> IO [Ptr b]
unpackZeroTerminatedPtrArray :: Ptr (Ptr a) -> IO [Ptr a]
mapZeroTerminatedCArray :: (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()

-- | Given a set of pointers to blocks of memory of the specified size,
--   copy the contents of these blocks to a freshly-allocated (with
--   <a>allocBytes</a>) continuous area of memory.
packBlockArray :: Int -> [Ptr a] -> IO (Ptr a)
unpackBlockArrayWithLength :: Integral a => Int -> a -> Ptr b -> IO [Ptr b]
unpackBoxedArrayWithLength :: (Integral a, GBoxed b) => Int -> a -> Ptr b -> IO [Ptr b]
mapCArrayWithLength :: (Storable a, Integral b) => b -> (a -> IO c) -> Ptr a -> IO ()
mapGArray :: Storable a => (a -> IO b) -> Ptr (GArray a) -> IO ()
mapPtrArray :: (Ptr a -> IO b) -> Ptr (GPtrArray (Ptr a)) -> IO ()
mapGList :: (Ptr a -> IO b) -> Ptr (GList (Ptr a)) -> IO ()
mapGSList :: (Ptr a -> IO b) -> Ptr (GSList (Ptr a)) -> IO ()

-- | An alias for <tt>Nothing :: Maybe GVariant</tt> to save some typing.
noGVariant :: Maybe GVariant

-- | Get the expected type of a <a>GVariant</a>, in <a>GVariant</a>
--   notation. See <a>https://docs.gtk.org/glib/struct.VariantType.html</a>
--   for the meaning of the resulting format string.
gvariantGetTypeString :: GVariant -> IO Text

-- | Take ownership of a passed in <a>Ptr</a> (typically created just for
--   us, so if it is floating we sink it).
wrapGVariantPtr :: Ptr GVariant -> IO GVariant

-- | Construct a Haskell wrapper for the given <a>GVariant</a>, without
--   assuming ownership.
newGVariantFromPtr :: Ptr GVariant -> IO GVariant

-- | Remove a reference to the given <a>GVariant</a>.
unrefGVariant :: GVariant -> IO ()

-- | Disown a <a>GVariant</a>, i.e. do not unref the underlying object when
--   the Haskell object is garbage collected.
disownGVariant :: GVariant -> IO (Ptr GVariant)
gvariantFromBool :: Bool -> IO GVariant
gvariantToBool :: GVariant -> IO (Maybe Bool)
gvariantFromWord8 :: Word8 -> IO GVariant
gvariantToWord8 :: GVariant -> IO (Maybe Word8)
gvariantFromInt16 :: Int16 -> IO GVariant
gvariantToInt16 :: GVariant -> IO (Maybe Int16)
gvariantFromWord16 :: Word16 -> IO GVariant
gvariantToWord16 :: GVariant -> IO (Maybe Word16)
gvariantFromInt32 :: Int32 -> IO GVariant
gvariantToInt32 :: GVariant -> IO (Maybe Int32)
gvariantFromWord32 :: Word32 -> IO GVariant
gvariantToWord32 :: GVariant -> IO (Maybe Word32)
gvariantFromInt64 :: Int64 -> IO GVariant
gvariantToInt64 :: GVariant -> IO (Maybe Int64)
gvariantFromWord64 :: Word64 -> IO GVariant
gvariantToWord64 :: GVariant -> IO (Maybe Word64)

-- | Convert a DBus handle (an <a>Int32</a>) into a <a>GVariant</a>.
gvariantFromHandle :: Int32 -> IO GVariant

-- | Extract the DBus handle (an <a>Int32</a>) inside a <a>GVariant</a>.
gvariantToHandle :: GVariant -> IO (Maybe Int32)
gvariantFromDouble :: Double -> IO GVariant
gvariantToDouble :: GVariant -> IO (Maybe Double)

-- | Decode an UTF-8 encoded string <a>GVariant</a> into <a>Text</a>.
gvariantToText :: GVariant -> IO (Maybe Text)

-- | Encode a <a>Text</a> into an UTF-8 encoded string <a>GVariant</a>.
gvariantFromText :: Text -> IO GVariant

-- | Try to construct a DBus object path. If the passed string is not a
--   valid object path <a>Nothing</a> will be returned.
newGVariantObjectPath :: Text -> Maybe GVariantObjectPath

-- | Return the <a>Text</a> representation of a <a>GVariantObjectPath</a>.
gvariantObjectPathToText :: GVariantObjectPath -> Text

-- | Construct a <a>GVariant</a> containing an object path. In order to
--   build a <a>GVariantObjectPath</a> value see
--   <a>newGVariantObjectPath</a>.
gvariantFromObjectPath :: GVariantObjectPath -> IO GVariant

-- | Extract a <a>GVariantObjectPath</a> from a <a>GVariant</a>,
--   represented as its underlying <a>Text</a> representation.
gvariantToObjectPath :: GVariant -> IO (Maybe Text)

-- | Try to construct a DBus object path. If the passed string is not a
--   valid DBus signature <a>Nothing</a> will be returned.
newGVariantSignature :: Text -> Maybe GVariantSignature

-- | Return the <a>Text</a> representation of a <a>GVariantSignature</a>.
gvariantSignatureToText :: GVariantSignature -> Text

-- | Construct a <a>GVariant</a> containing an DBus signature. In order to
--   build a <a>GVariantSignature</a> value see
--   <a>newGVariantSignature</a>.
gvariantFromSignature :: GVariantSignature -> IO GVariant

-- | Extract a <a>GVariantSignature</a> from a <a>GVariant</a>, represented
--   as <a>Text</a>.
gvariantToSignature :: GVariant -> IO (Maybe Text)

-- | Box a <a>GVariant</a> inside another <a>GVariant</a>.
gvariantFromGVariant :: GVariant -> IO GVariant

-- | Unbox a <a>GVariant</a> contained inside another <a>GVariant</a>.
gvariantToGVariant :: GVariant -> IO (Maybe GVariant)

-- | Extract a zero terminated list of bytes into a <a>ByteString</a>.
gvariantToBytestring :: GVariant -> IO (Maybe ByteString)

-- | Encode a <a>ByteString</a> into a list of bytes <a>GVariant</a>.
gvariantFromBytestring :: ByteString -> IO GVariant

-- | Convert a <a>Maybe</a> value into a corresponding <a>GVariant</a> of
--   maybe type.
gvariantFromMaybe :: IsGVariant a => Maybe a -> IO GVariant

-- | Try to decode a maybe <a>GVariant</a> into the corresponding
--   <a>Maybe</a> type. If the conversion is successful this returns
--   <tt>Just x</tt>, where <tt>x</tt> itself is of <a>Maybe</a> type. So,
--   in particular, <tt>Just Nothing</tt> indicates a successful call, and
--   means that the GVariant of maybe type was empty.
gvariantToMaybe :: IsGVariant a => GVariant -> IO (Maybe (Maybe a))

-- | Construct a <a>GVariant</a> of type DictEntry from the given
--   <tt>key</tt> and <tt>value</tt>. The key must be a basic
--   <a>GVariant</a> type, i.e. not a container. This is determined by
--   whether it belongs to the <a>IsGVariantBasicType</a> typeclass. On the
--   other hand <tt>value</tt> is an arbitrary <a>GVariant</a>, and in
--   particular it can be a container type.
gvariantFromDictEntry :: (IsGVariant key, IsGVariantBasicType key, IsGVariant value) => key -> value -> IO GVariant

-- | Unpack a DictEntry variant into <tt>key</tt> and <tt>value</tt>, which
--   are returned as a two element tuple in case of success.
gvariantToDictEntry :: (IsGVariant key, IsGVariantBasicType key, IsGVariant value) => GVariant -> IO (Maybe (key, value))

-- | Pack a <tt>Map</tt> into a <a>GVariant</a> for dictionary type, which
--   is just an array of <a>GVariantDictEntry</a>.
gvariantFromMap :: (IsGVariant key, IsGVariantBasicType key, IsGVariant value) => Map key value -> IO GVariant

-- | Unpack a <a>GVariant</a> into a <a>Map</a>. Notice that this assumes
--   that all the elements in the <a>GVariant</a> array of
--   <a>GVariantDictEntry</a> are of the same type, which is not necessary
--   for a generic <a>GVariant</a>, so this is somewhat restrictive. For
--   the general case it is necessary to use <a>gvariantToList</a> plus
--   <a>gvariantToDictEntry</a> directly.
gvariantToMap :: (IsGVariant key, IsGVariantBasicType key, IsGVariant value) => GVariant -> IO (Maybe (Map key value))

-- | Given a list of elements construct a <a>GVariant</a> array containing
--   them.
gvariantFromList :: IsGVariant a => [a] -> IO GVariant

-- | Unpack a <a>GVariant</a> array into its elements.
gvariantToList :: IsGVariant a => GVariant -> IO (Maybe [a])

-- | Given a list of <a>GVariant</a>, construct a <a>GVariant</a> tuple
--   containing the elements in the list.
gvariantFromTuple :: [GVariant] -> IO GVariant

-- | Extract the children of a <a>GVariant</a> tuple into a list.
gvariantToTuple :: GVariant -> IO (Maybe [GVariant])

-- | Check whether two <a>CString</a>s are equal.
gStrEqual :: GEqualFunc CString

-- | Compute the hash for a <a>CString</a>.
gStrHash :: GHashFunc CString

-- | Check whether two pointers are equal.
gDirectEqual :: GEqualFunc (Ptr a)

-- | Compute the hash for a <a>Ptr</a>.
gDirectHash :: GHashFunc (Ptr a)

-- | Pack a <a>Ptr</a> into a <a>PtrWrapped</a> <a>Ptr</a>.
ptrPackPtr :: Ptr a -> PtrWrapped (Ptr a)

-- | Extract a <a>Ptr</a> from a <a>PtrWrapped</a> <a>Ptr</a>.
ptrUnpackPtr :: PtrWrapped (Ptr a) -> Ptr a

-- | Pack a <a>CString</a> into a <a>Ptr</a> than can go into a
--   <tt>GHashTable</tt>.
cstringPackPtr :: CString -> PtrWrapped CString

-- | Extract a <a>CString</a> wrapped into a <a>Ptr</a> coming from a
--   <tt>GHashTable</tt>.
cstringUnpackPtr :: PtrWrapped CString -> CString

-- | Pack a <a>Ptr</a> to <a>GValue</a> into a <a>Ptr</a> than can go into
--   a <tt>GHashTable</tt>.
gvaluePackPtr :: Ptr GValue -> PtrWrapped (Ptr GValue)

-- | Extract a <a>Ptr</a> to <a>GValue</a> wrapped into a <a>Ptr</a> coming
--   from a <tt>GHashTable</tt>.
gvalueUnpackPtr :: PtrWrapped (Ptr GValue) -> Ptr GValue

-- | Create a new <a>GError</a>.
gerrorNew :: GErrorDomain -> GErrorCode -> GErrorMessage -> IO GError

-- | Return the domain for the given <a>GError</a>. This is a GQuark, a
--   textual representation can be obtained with <a>quarkToString</a>.
gerrorDomain :: GError -> IO GQuark

-- | The numeric code for the given <a>GError</a>.
gerrorCode :: GError -> IO GErrorCode

-- | A text message describing the <a>GError</a>.
gerrorMessage :: GError -> IO GErrorMessage

-- | This will catch just a specific GError exception. If you need to catch
--   a range of related errors, <a>catchGErrorJustDomain</a> is probably
--   more appropriate. Example:
--   
--   <pre>
--   do image &lt;- catchGErrorJust PixbufErrorCorruptImage
--                 loadImage
--                 (\errorMessage -&gt; do log errorMessage
--                                      return mssingImagePlaceholder)
--   </pre>
catchGErrorJust :: GErrorClass err => err -> IO a -> (GErrorMessage -> IO a) -> IO a

-- | A verson of <a>handleGErrorJust</a> with the arguments swapped around.
handleGErrorJust :: GErrorClass err => err -> (GErrorMessage -> IO a) -> IO a -> IO a

-- | Run the given function catching possible <a>GError</a>s in its
--   execution. If a <a>GError</a> is emitted this throws the corresponding
--   exception.
propagateGError :: (Ptr (Ptr GError) -> IO a) -> IO a

-- | Like <a>propagateGError</a>, but allows to specify a custom handler
--   instead of just throwing the exception.
checkGError :: (Ptr (Ptr GError) -> IO a) -> (GError -> IO a) -> IO a

-- | If the passed in <tt><a>Maybe</a> <a>GError</a></tt> is not
--   <a>Nothing</a>, store a copy in the passed in pointer, unless the
--   pointer is <a>nullPtr</a>.
maybePokeGError :: Ptr (Ptr GError) -> Maybe GError -> IO ()

-- | Generate a function pointer callable from C code, from a
--   <a>C_TranslateFunc</a>.
mk_TranslateFunc :: C_TranslateFunc -> IO (FunPtr C_TranslateFunc)

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TranslateFunc :: (HasCallStack, MonadIO m) => FunPtr C_TranslateFunc -> Text -> Ptr () -> m Text

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TranslateFunc</a></tt>.
noTranslateFunc :: Maybe TranslateFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TranslateFunc_WithClosures</a></tt>.
noTranslateFunc_WithClosures :: Maybe TranslateFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TranslateFunc :: TranslateFunc -> TranslateFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TranslateFunc :: MonadIO m => TranslateFunc -> m (GClosure C_TranslateFunc)

-- | Wrap a <a>TranslateFunc</a> into a <a>C_TranslateFunc</a>.
wrap_TranslateFunc :: Maybe (Ptr (FunPtr C_TranslateFunc)) -> TranslateFunc_WithClosures -> C_TranslateFunc

-- | Checks that the GTK+ library in use is compatible with the given
--   version. Generally you would pass in the constants
--   <a>MAJOR_VERSION</a>, <a>MINOR_VERSION</a>, <a>MICRO_VERSION</a> as
--   the three arguments to this function; that produces a check that the
--   library in use is compatible with the version of GTK+ the application
--   or module was compiled against.
--   
--   Compatibility is defined by two things: first the version of the
--   running library is newer than the version
--   <i><tt>requiredMajor</tt></i>.required_minor.<i><tt>requiredMicro</tt></i>.
--   Second the running library must be binary compatible with the version
--   <i><tt>requiredMajor</tt></i>.required_minor.<i><tt>requiredMicro</tt></i>
--   (same major version.)
--   
--   This function is primarily for GTK+ modules; the module can call this
--   function to check that it wasn’t loaded into an incompatible version
--   of GTK+. However, such a check isn’t completely reliable, since the
--   module may be linked against an old version of GTK+ and calling the
--   old version of <a>checkVersion</a>, but still get loaded into an
--   application using a newer version of GTK+.
checkVersion :: (HasCallStack, MonadIO m) => Word32 -> Word32 -> Word32 -> m (Maybe Text)

-- | Generate a function pointer callable from C code, from a
--   <a>C_Callback</a>.
mk_Callback :: C_Callback -> IO (FunPtr C_Callback)

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_Callback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_Callback -> a -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>Callback</a></tt>.
noCallback :: Maybe Callback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_Callback :: MonadIO m => Callback -> m (GClosure C_Callback)

-- | Wrap a <a>Callback</a> into a <a>C_Callback</a>.
wrap_Callback :: Maybe (Ptr (FunPtr C_Callback)) -> Callback_WithClosures -> C_Callback

-- | Returns the binary age as passed to <tt>libtool</tt> when building the
--   GTK+ library the process is running against. If <tt>libtool</tt> means
--   nothing to you, don't worry about it.
--   
--   <i>Since: 3.0</i>
getBinaryAge :: (HasCallStack, MonadIO m) => m Word32

-- | Returns the interface age as passed to <tt>libtool</tt> when building
--   the GTK+ library the process is running against. If <tt>libtool</tt>
--   means nothing to you, don't worry about it.
--   
--   <i>Since: 3.0</i>
getInterfaceAge :: (HasCallStack, MonadIO m) => m Word32

-- | Returns the major version number of the GTK+ library. (e.g. in GTK+
--   version 3.1.5 this is 3.)
--   
--   This function is in the library, so it represents the GTK+ library
--   your code is running against. Contrast with the <a>MAJOR_VERSION</a>
--   macro, which represents the major version of the GTK+ headers you have
--   included when compiling your code.
--   
--   <i>Since: 3.0</i>
getMajorVersion :: (HasCallStack, MonadIO m) => m Word32

-- | Returns the micro version number of the GTK+ library. (e.g. in GTK+
--   version 3.1.5 this is 5.)
--   
--   This function is in the library, so it represents the GTK+ library
--   your code is are running against. Contrast with the
--   <a>MICRO_VERSION</a> macro, which represents the micro version of the
--   GTK+ headers you have included when compiling your code.
--   
--   <i>Since: 3.0</i>
getMicroVersion :: (HasCallStack, MonadIO m) => m Word32

-- | Returns the minor version number of the GTK+ library. (e.g. in GTK+
--   version 3.1.5 this is 1.)
--   
--   This function is in the library, so it represents the GTK+ library
--   your code is are running against. Contrast with the
--   <a>MINOR_VERSION</a> macro, which represents the minor version of the
--   GTK+ headers you have included when compiling your code.
--   
--   <i>Since: 3.0</i>
getMinorVersion :: (HasCallStack, MonadIO m) => m Word32

-- | Renders a frame around the rectangle defined by <i><tt>x</tt></i>,
--   <i><tt>y</tt></i>, <i><tt>width</tt></i>, <i><tt>height</tt></i>.
--   
--   Examples of frame rendering, showing the effect of
--   <tt>border-image</tt>, <tt>border-color</tt>, <tt>border-width</tt>,
--   <tt>border-radius</tt> and junctions:
--   
--   
--   <i>Since: 3.0</i>
renderFrame :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Sets the current sort column to be <i><tt>sortColumnId</tt></i>. The
--   <i><tt>sortable</tt></i> will resort itself to reflect this change,
--   after emitting a <a>TreeSortable::sortColumnChanged</a> signal.
--   <i><tt>sortColumnId</tt></i> may either be a regular column id, or one
--   of the following special values:
--   
--   <ul>
--   <li><a>TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID</a>: the default sort
--   function will be used, if it is set</li>
--   <li><a>TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID</a>: no sorting will
--   occur</li>
--   </ul>
treeSortableSetSortColumnId :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> Int32 -> SortType -> m ()

-- | Erases the visited page history so the back button is not shown on the
--   current page, and removes the cancel button from subsequent pages.
--   
--   Use this when the information provided up to the current page is
--   hereafter deemed permanent and cannot be modified or undone. For
--   example, showing a progress page to track a long-running, unreversible
--   operation after the user has clicked apply on a confirmation page.
--   
--   <i>Since: 2.22</i>
assistantCommit :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m ()

-- | Gets the type of representation being used by the <a>Image</a> to
--   store image data. If the <a>Image</a> has no image data, the return
--   value will be <a>ImageTypeEmpty</a>.
imageGetStorageType :: (HasCallStack, MonadIO m, IsImage a) => a -> m ImageType

-- | Gets the <a>Pixbuf</a> being displayed by the <a>Image</a>. The
--   storage type of the image must be <a>ImageTypeEmpty</a> or
--   <a>ImageTypePixbuf</a> (see <a>imageGetStorageType</a>). The caller of
--   this function does not own a reference to the returned pixbuf.
imageGetPixbuf :: (HasCallStack, MonadIO m, IsImage a) => a -> m (Maybe Pixbuf)

-- | Gets the stock icon name and size being displayed by the <a>Image</a>.
--   The storage type of the image must be <a>ImageTypeEmpty</a> or
--   <a>ImageTypeStock</a> (see <a>imageGetStorageType</a>). The returned
--   string is owned by the <a>Image</a> and should not be freed.
imageGetStock :: (HasCallStack, MonadIO m, IsImage a) => a -> m (Text, Int32)

-- | Sets the value of <a>PRINT_SETTINGS_ORIENTATION</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetOrientation :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PageOrientation -> m ()

-- | This function was used internally by the GtkRC parsing mechanism to
--   assign match patterns to <a>BindingSet</a> structures.
--   
--   In GTK+ 3, these match patterns are unused.
bindingSetAddPath :: (HasCallStack, MonadIO m) => BindingSet -> PathType -> Text -> PathPriorityType -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_DUPLEX</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetDuplex :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PrintDuplex -> m ()

-- | Runs the print operation, by first letting the user modify print
--   settings in the print dialog, and then print the document.
--   
--   Normally that this function does not return until the rendering of all
--   pages is complete. You can connect to the
--   <a>PrintOperation::statusChanged</a> signal on <i><tt>op</tt></i> to
--   obtain some information about the progress of the print operation.
--   Furthermore, it may use a recursive mainloop to show the print dialog.
--   
--   If you call <a>printOperationSetAllowAsync</a> or set the
--   <a>PrintOperation:allowAsync</a> property the operation will run
--   asynchronously if this is supported on the platform. The
--   <a>PrintOperation::done</a> signal will be emitted with the result of
--   the operation when the it is done (i.e. when the dialog is canceled,
--   or when the print succeeds or fails).
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   if (settings != NULL)
--     gtk_print_operation_set_print_settings (print, settings);
--     
--   if (page_setup != NULL)
--     gtk_print_operation_set_default_page_setup (print, page_setup);
--     
--   g_signal_connect (print, "begin-print",
--                     G_CALLBACK (begin_print), &amp;data);
--   g_signal_connect (print, "draw-page",
--                     G_CALLBACK (draw_page), &amp;data);
--    
--   res = gtk_print_operation_run (print,
--                                  GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
--                                  parent,
--                                  &amp;error);
--    
--   if (res == GTK_PRINT_OPERATION_RESULT_ERROR)
--    {
--      error_dialog = gtk_message_dialog_new (GTK_WINDOW (parent),
--     			                     GTK_DIALOG_DESTROY_WITH_PARENT,
--   					     GTK_MESSAGE_ERROR,
--   					     GTK_BUTTONS_CLOSE,
--   					     "Error printing file:\n%s",
--   					     error-&gt;message);
--      g_signal_connect (error_dialog, "response",
--                        G_CALLBACK (gtk_widget_destroy), NULL);
--      gtk_widget_show (error_dialog);
--      g_error_free (error);
--    }
--   else if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
--    {
--      if (settings != NULL)
--   g_object_unref (settings);
--      settings = g_object_ref (gtk_print_operation_get_print_settings (print));
--    }
--   </pre>
--   
--   Note that <a>printOperationRun</a> can only be called once on a given
--   <a>PrintOperation</a>.
--   
--   <i>Since: 2.10</i>
printOperationRun :: (HasCallStack, MonadIO m, IsPrintOperation a, IsWindow b) => a -> PrintOperationAction -> Maybe b -> m PrintOperationResult

-- | Sets the value of <a>PRINT_SETTINGS_QUALITY</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetQuality :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PrintQuality -> m ()

-- | Adds a button with the given text and sets things up so that clicking
--   the button will emit the <a>Dialog::response</a> signal with the given
--   <i><tt>responseId</tt></i>. The button is appended to the end of the
--   dialog’s action area. The button widget is returned, but usually you
--   don’t need it.
dialogAddButton :: (HasCallStack, MonadIO m, IsDialog a) => a -> Text -> Int32 -> m Widget

-- | Sets the update behavior of a spin button. This determines whether the
--   spin button is always updated or only when a valid value is set.
spinButtonSetUpdatePolicy :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> SpinButtonUpdatePolicy -> m ()

-- | Increment or decrement a spin button’s value in a specified direction
--   by a specified amount.
spinButtonSpin :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> SpinType -> Double -> m ()

-- | This function returns the list of targets this text buffer can provide
--   for copying and as DND source. The targets in the list are added with
--   <i><tt>info</tt></i> values from the <a>TextBufferTargetInfo</a> enum,
--   using <a>targetListAddRichTextTargets</a> and
--   <a>targetListAddTextTargets</a>.
--   
--   <i>Since: 2.10</i>
textBufferGetCopyTargetList :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TargetList

-- | This function returns the list of targets this text buffer supports
--   for pasting and as DND destination. The targets in the list are added
--   with <i><tt>info</tt></i> values from the <a>TextBufferTargetInfo</a>
--   enum, using <a>targetListAddRichTextTargets</a> and
--   <a>targetListAddTextTargets</a>.
--   
--   <i>Since: 2.10</i>
textBufferGetPasteTargetList :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TargetList

-- | Sets the value of <a>PRINT_SETTINGS_PAPER_WIDTH</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetPaperWidth :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Double -> Unit -> m ()

-- | By default, windows are decorated with a title bar, resize controls,
--   etc. Some [window managers][gtk-X11-arch] allow GTK+ to disable these
--   decorations, creating a borderless window. If you set the decorated
--   property to <a>False</a> using this function, GTK+ will do its best to
--   convince the window manager not to decorate the window. Depending on
--   the system, this function may not have any effect when called on a
--   window that is already visible, so you should call it before calling
--   <a>widgetShow</a>.
--   
--   On Windows, this function always works, since there’s no window
--   manager policy involved.
windowSetDecorated :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Adds a widget to the action area of a <a>Assistant</a>.
--   
--   <i>Since: 2.10</i>
assistantAddActionWidget :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m ()

-- | Sets the <a>Box:homogeneous</a> property of <i><tt>box</tt></i>,
--   controlling whether or not all children of <i><tt>box</tt></i> are
--   given equal space in the box.
boxSetHomogeneous :: (HasCallStack, MonadIO m, IsBox a) => a -> Bool -> m ()

-- | Sets the <a>Box:spacing</a> property of <i><tt>box</tt></i>, which is
--   the number of pixels to place between children of <i><tt>box</tt></i>.
boxSetSpacing :: (HasCallStack, MonadIO m, IsBox a) => a -> Int32 -> m ()

-- | Gets the parent section for the given <i><tt>section</tt></i>. The
--   parent section is the section that contains this
--   <i><tt>section</tt></i>. A special case are sections of type
--   <tt><i>GTK_CSS_SECTION_DOCUMENT</i></tt>. Their parent will either be
--   <a>Nothing</a> if they are the original CSS document that was loaded
--   by <a>cssProviderLoadFromFile</a> or a section of type
--   <tt><i>GTK_CSS_SECTION_IMPORT</i></tt> if it was loaded with an import
--   rule from a different file.
--   
--   <i>Since: 3.2</i>
cssSectionGetParent :: (HasCallStack, MonadIO m) => CssSection -> m (Maybe CssSection)

-- | Feeds an events into <i><tt>controller</tt></i>, so it can be
--   interpreted and the controller actions triggered.
--   
--   <i>Since: 3.14</i>
eventControllerHandleEvent :: (HasCallStack, MonadIO m, IsEventController a) => a -> Event -> m Bool

-- | Sets the comparison function used when sorting to be
--   <i><tt>sortFunc</tt></i>. If the <i><tt>chooser</tt></i> has the sort
--   type set to <tt><i>GTK_RECENT_SORT_CUSTOM</i></tt> then the chooser
--   will sort using this function.
--   
--   To the comparison function will be passed two <a>RecentInfo</a>
--   structs and <i><tt>sortData</tt></i>; <i><tt>sortFunc</tt></i> should
--   return a positive integer if the first item comes before the second,
--   zero if the two items are equal and a negative integer if the first
--   item comes after the second.
--   
--   <i>Since: 2.10</i>
recentChooserSetSortFunc :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> RecentSortFunc -> m ()

-- | Installs an accelerator in this group. When <i><tt>accelGroup</tt></i>
--   is being activated in response to a call to
--   <a>accelGroupsActivate</a>, <i><tt>closure</tt></i> will be invoked if
--   the <i><tt>accelKey</tt></i> and <i><tt>accelMods</tt></i> from
--   <a>accelGroupsActivate</a> match those of this connection.
--   
--   The signature used for the <i><tt>closure</tt></i> is that of
--   <a>AccelGroupActivate</a>.
--   
--   Note that, due to implementation details, a single closure can only be
--   connected to one accelerator group.
accelGroupConnect :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> Word32 -> [ModifierType] -> [AccelFlags] -> GClosure C_AccelGroupActivate -> m ()

-- | Inform the session manager that certain types of actions should be
--   inhibited. This is not guaranteed to work on all platforms and for all
--   types of actions.
--   
--   Applications should invoke this method when they begin an operation
--   that should not be interrupted, such as creating a CD or DVD. The
--   types of actions that may be blocked are specified by the
--   <i><tt>flags</tt></i> parameter. When the application completes the
--   operation it should call <a>applicationUninhibit</a> to remove the
--   inhibitor. Note that an application can have multiple inhibitors, and
--   all of them must be individually removed. Inhibitors are also cleared
--   when the application exits.
--   
--   Applications should not expect that they will always be able to block
--   the action. In most cases, users will be given the option to force the
--   action to take place.
--   
--   Reasons should be short and to the point.
--   
--   If <i><tt>window</tt></i> is given, the session manager may point the
--   user to this window to find out more about why the action is
--   inhibited.
--   
--   <i>Since: 3.4</i>
applicationInhibit :: (HasCallStack, MonadIO m, IsApplication a, IsWindow b) => a -> Maybe b -> [ApplicationInhibitFlags] -> Maybe Text -> m Word32

-- | Looks up a named icon and returns a <a>IconInfo</a> containing
--   information such as the filename of the icon. The icon can then be
--   rendered into a pixbuf using <a>iconInfoLoadIcon</a>.
--   (<a>iconThemeLoadIcon</a> combines these two steps if all you need is
--   the pixbuf.)
--   
--   When rendering on displays with high pixel densities you should not
--   use a <i><tt>size</tt></i> multiplied by the scaling factor returned
--   by functions like <a>windowGetScaleFactor</a>. Instead, you should use
--   <a>iconThemeLookupIconForScale</a>, as the assets loaded for a given
--   scaling factor may be different.
--   
--   <i>Since: 2.4</i>
iconThemeLookupIcon :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> Int32 -> [IconLookupFlags] -> m (Maybe IconInfo)

-- | Sets the way in which the calling application can open new locations
--   from the places sidebar. For example, some applications only open
--   locations “directly” into their main view, while others may support
--   opening locations in a new notebook tab or a new window.
--   
--   This function is used to tell the places <i><tt>sidebar</tt></i> about
--   the ways in which the application can open new locations, so that the
--   sidebar can display (or not) the “Open in new tab” and “Open in new
--   window” menu items as appropriate.
--   
--   When the <a>PlacesSidebar::openLocation</a> signal is emitted, its
--   flags argument will be set to one of the <i><tt>flags</tt></i> that
--   was passed in <a>placesSidebarSetOpenFlags</a>.
--   
--   Passing 0 for <i><tt>flags</tt></i> will cause
--   <tt><i>GTK_PLACES_OPEN_NORMAL</i></tt> to always be sent to callbacks
--   for the “open-location” signal.
--   
--   <i>Since: 3.10</i>
placesSidebarSetOpenFlags :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> [PlacesOpenFlags] -> m ()

-- | Converts the style context into a string representation.
--   
--   The string representation always includes information about the name,
--   state, id, visibility and style classes of the CSS node that is
--   backing <i><tt>context</tt></i>. Depending on the flags, more
--   information may be included.
--   
--   This function is intended for testing and debugging of the CSS
--   implementation in GTK+. There are no guarantees about the format of
--   the returned string, it may change.
--   
--   <i>Since: 3.20</i>
styleContextToString :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StyleContextPrintFlags] -> m Text

-- | Returns a set of flags supported by this interface.
--   
--   The flags are a bitwise combination of <a>TreeModelFlags</a>. The
--   flags supported should not change during the lifetime of the
--   <i><tt>treeModel</tt></i>.
treeModelGetFlags :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m [TreeModelFlags]

-- | Adds a UI element to the current contents of <i><tt>manager</tt></i>.
--   
--   If <i><tt>type</tt></i> is <a>UIManagerItemTypeAuto</a>, GTK+ inserts
--   a menuitem, toolitem or separator if such an element can be inserted
--   at the place determined by <i><tt>path</tt></i>. Otherwise
--   <i><tt>type</tt></i> must indicate an element that can be inserted at
--   the place determined by <i><tt>path</tt></i>.
--   
--   If <i><tt>path</tt></i> points to a menuitem or toolitem, the new
--   element will be inserted before or after this item, depending on
--   <i><tt>top</tt></i>.
--   
--   <i>Since: 2.4</i>
uIManagerAddUi :: (HasCallStack, MonadIO m, IsUIManager a) => a -> Word32 -> Text -> Text -> Maybe Text -> [UIManagerItemType] -> Bool -> m ()

-- | Installs a function which provides Pango markup with detail
--   information for each day. Examples for such details are holidays or
--   appointments. That information is shown below each day when
--   <a>Calendar:showDetails</a> is set. A tooltip containing with full
--   detail information is provided, if the entire text should not fit into
--   the details area, or if <a>Calendar:showDetails</a> is not set.
--   
--   The size of the details area can be restricted by setting the
--   <a>Calendar:detailWidthChars</a> and <a>Calendar:detailHeightRows</a>
--   properties.
--   
--   <i>Since: 2.14</i>
calendarSetDetailFunc :: (HasCallStack, MonadIO m, IsCalendar a) => a -> CalendarDetailFunc -> m ()

-- | Gets the data associated with a drag. When the data is received or the
--   retrieval fails, GTK+ will emit a <a>Widget::dragDataReceived</a>
--   signal. Failure of the retrieval is indicated by the length field of
--   the <i><tt>selectionData</tt></i> signal parameter being negative.
--   However, when <a>widgetDragGetData</a> is called implicitely because
--   the <a>DestDefaultsDrop</a> was set, then the widget will not receive
--   notification of failed drops.
widgetDragGetData :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => a -> b -> Atom -> Word32 -> m ()

-- | Informs the drag source that the drop is finished, and that the data
--   of the drag will no longer be required.
dragFinish :: (HasCallStack, MonadIO m, IsDragContext a) => a -> Bool -> Bool -> Word32 -> m ()

-- | Sets a window modal or non-modal. Modal windows prevent interaction
--   with other windows in the same application. To keep modal dialogs on
--   top of main application windows, use <a>windowSetTransientFor</a> to
--   make the dialog transient for the parent; most [window
--   managers][gtk-X11-arch] will then disallow lowering the dialog below
--   the parent.
windowSetModal :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | If <i><tt>setting</tt></i> is <a>True</a>, then destroying the
--   transient parent of <i><tt>window</tt></i> will also destroy
--   <i><tt>window</tt></i> itself. This is useful for dialogs that
--   shouldn’t persist beyond the lifetime of the main window they're
--   associated with, for example.
windowSetDestroyWithParent :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Gets the filename for the icon. If the
--   <a>IconLookupFlagsUseBuiltin</a> flag was passed to
--   <a>iconThemeLookupIcon</a>, there may be no filename if a builtin icon
--   is returned; in this case, you should use
--   <a>iconInfoGetBuiltinPixbuf</a>.
--   
--   <i>Since: 2.4</i>
iconInfoGetFilename :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m (Maybe [Char])

-- | Gets the built-in image for this icon, if any. To allow GTK+ to use
--   built in icon images, you must pass the
--   <a>IconLookupFlagsUseBuiltin</a> to <a>iconThemeLookupIcon</a>.
--   
--   <i>Since: 2.4</i>
iconInfoGetBuiltinPixbuf :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m (Maybe Pixbuf)

-- | Looks up a named icon and returns a <a>IconInfo</a> containing
--   information such as the filename of the icon. The icon can then be
--   rendered into a pixbuf using <a>iconInfoLoadIcon</a>.
--   (<a>iconThemeLoadIcon</a> combines these two steps if all you need is
--   the pixbuf.)
--   
--   If <i><tt>iconNames</tt></i> contains more than one name, this
--   function tries them all in the given order before falling back to
--   inherited icon themes.
--   
--   <i>Since: 2.12</i>
iconThemeChooseIcon :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> [Text] -> Int32 -> [IconLookupFlags] -> m (Maybe IconInfo)

-- | Parses a string representing an accelerator. The format looks like
--   “&lt;Control&gt;a” or “&lt;Shift&gt;&lt;Alt&gt;F1” or
--   “&lt;Release&gt;z” (the last one is for key release).
--   
--   The parser is fairly liberal and allows lower or upper case, and also
--   abbreviations such as “&lt;Ctl&gt;” and “&lt;Ctrl&gt;”. Key names are
--   parsed using <a>keyvalFromName</a>. For character keys the name is not
--   the symbol, but the lowercase name, e.g. one would use
--   “&lt;Ctrl&gt;minus” instead of “&lt;Ctrl&gt;-”.
--   
--   If the parse fails, <i><tt>acceleratorKey</tt></i> and
--   <i><tt>acceleratorMods</tt></i> will be set to 0 (zero).
acceleratorParse :: (HasCallStack, MonadIO m) => Text -> m (Word32, [ModifierType])

-- | Loads the data contained in <i><tt>file</tt></i> into
--   <i><tt>cssProvider</tt></i>, making it clear any previously loaded
--   information.
cssProviderLoadFromFile :: (HasCallStack, MonadIO m, IsCssProvider a, IsFile b) => a -> b -> m ()

-- | Creates a new <a>IconSet</a> with <i><tt>pixbuf</tt></i> as the
--   default/fallback source image. If you don’t add any additional
--   <a>IconSource</a> to the icon set, all variants of the icon will be
--   created from <i><tt>pixbuf</tt></i>, using scaling, pixelation, etc.
--   as required to adjust the icon size or make the icon look
--   insensitive/prelighted.
iconSetNewFromPixbuf :: (HasCallStack, MonadIO m, IsPixbuf a) => a -> m IconSet

-- | Icon sets have a list of <a>IconSource</a>, which they use as base
--   icons for rendering icons in different states and sizes. Icons are
--   scaled, made to look insensitive, etc. in <a>iconSetRenderIcon</a>,
--   but <a>IconSet</a> needs base images to work with. The base images and
--   when to use them are described by a <a>IconSource</a>.
--   
--   This function copies <i><tt>source</tt></i>, so you can reuse the same
--   source immediately without affecting the icon set.
--   
--   An example of when you’d use this function: a web browser’s "Back to
--   Previous Page" icon might point in a different direction in Hebrew and
--   in English; it might look different when insensitive; and it might
--   change size depending on toolbar mode (small/large icons). So a single
--   icon set would contain all those variants of the icon, and you might
--   add a separate source for each one.
--   
--   You should nearly always add a “default” icon source with all fields
--   wildcarded, which will be used as a fallback if no more specific
--   source matches. <a>IconSet</a> always prefers more specific icon
--   sources to more generic icon sources. The order in which you add the
--   sources to the icon set does not matter.
--   
--   <a>iconSetNewFromPixbuf</a> creates a new icon set with a default icon
--   source based on the given pixbuf.
iconSetAddSource :: (HasCallStack, MonadIO m) => IconSet -> IconSource -> m ()

-- | Returns the name of the default paper size, which depends on the
--   current locale.
--   
--   <i>Since: 2.10</i>
paperSizeGetDefault :: (HasCallStack, MonadIO m) => m Text

-- | Sets a new cairo context on a print context.
--   
--   This function is intended to be used when implementing an internal
--   print preview, it is not needed for printing, since GTK+ itself
--   creates a suitable cairo context in that case.
--   
--   <i>Since: 2.10</i>
printContextSetCairoContext :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> Context -> Double -> Double -> m ()

-- | <i>No description available in the introspection data.</i>
settingsInstallPropertyParser :: (HasCallStack, MonadIO m) => GParamSpec -> RcPropertyParser -> m ()

-- | Decreases the reference count of <i><tt>info</tt></i> by one. If the
--   reference count reaches zero, <i><tt>info</tt></i> is deallocated, and
--   the memory freed.
--   
--   <i>Since: 2.10</i>
recentInfoUnref :: (HasCallStack, MonadIO m) => RecentInfo -> m ()

-- | Sets the page forwarding function to be <i><tt>pageFunc</tt></i>.
--   
--   This function will be used to determine what will be the next page
--   when the user presses the forward button. Setting
--   <i><tt>pageFunc</tt></i> to <a>Nothing</a> will make the assistant to
--   use the default forward function, which just goes to the next visible
--   page.
--   
--   <i>Since: 2.10</i>
assistantSetForwardPageFunc :: (HasCallStack, MonadIO m, IsAssistant a) => a -> Maybe AssistantPageFunc -> m ()

-- | This method is a simpler variation of
--   <a>builderConnectSignalsFull</a>. It uses symbols explicitly added to
--   <i><tt>builder</tt></i> with prior calls to
--   <a>builderAddCallbackSymbol</a>. In the case that symbols are not
--   explicitly added; it uses <a>Module</a>’s introspective features (by
--   opening the module <a>Nothing</a>) to look at the application’s symbol
--   table. From here it tries to match the signal handler names given in
--   the interface description with symbols in the application and connects
--   the signals. Note that this function can only be called once,
--   subsequent calls will do nothing.
--   
--   Note that unless <a>builderAddCallbackSymbol</a> is called for all
--   signal callbacks which are referenced by the loaded XML, this function
--   will require that <a>Module</a> be supported on the platform.
--   
--   If you rely on <a>Module</a> support to lookup callbacks in the symbol
--   table, the following details should be noted:
--   
--   When compiling applications for Windows, you must declare signal
--   callbacks with <tt><i>G_MODULE_EXPORT</i></tt>, or they will not be
--   put in the symbol table. On Linux and Unices, this is not necessary;
--   applications should instead be compiled with the -Wl,--export-dynamic
--   CFLAGS, and linked against gmodule-export-2.0.
--   
--   <i>Since: 2.12</i>
builderConnectSignals :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Ptr () -> m ()

-- | This function can be thought of the interpreted language binding
--   version of <a>builderConnectSignals</a>, except that it does not
--   require GModule to function correctly.
--   
--   <i>Since: 2.12</i>
builderConnectSignalsFull :: (HasCallStack, MonadIO m, IsBuilder a) => a -> BuilderConnectFunc -> m ()

-- | Invokes <i><tt>callback</tt></i> on each non-internal child of
--   <i><tt>container</tt></i>. See <a>containerForall</a> for details on
--   what constitutes an “internal” child. For all practical purposes, this
--   function should iterate over precisely those child widgets that were
--   added to the container by the application with explicit
--   <tt><i>add()</i></tt> calls.
--   
--   It is permissible to remove the child from the
--   <i><tt>callback</tt></i> handler.
--   
--   Most applications should use <a>containerForeach</a>, rather than
--   <a>containerForall</a>.
containerForeach :: (HasCallStack, MonadIO m, IsContainer a) => a -> Callback -> m ()

-- | Calls <i><tt>callback</tt></i> for every <a>CellRenderer</a> in
--   <i><tt>area</tt></i> with the allocated rectangle inside
--   <i><tt>cellArea</tt></i>.
--   
--   <i>Since: 3.0</i>
cellAreaForeachAlloc :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Rectangle -> Rectangle -> CellAllocCallback -> m ()

-- | Calls <i><tt>callback</tt></i> for every <a>CellRenderer</a> in
--   <i><tt>area</tt></i>.
--   
--   <i>Since: 3.0</i>
cellAreaForeach :: (HasCallStack, MonadIO m, IsCellArea a) => a -> CellCallback -> m ()

-- | Stores new data into a <a>SelectionData</a> object. Should only be
--   called from a selection handler callback. Zero-terminates the stored
--   data.
selectionDataSet :: (HasCallStack, MonadIO m) => SelectionData -> Atom -> Int32 -> ByteString -> m ()

-- | Sets the contents of the selection from a UTF-8 encoded string. The
--   string is converted to the form determined by
--   <i><tt>selectionData</tt></i>-&gt;target.
selectionDataSetText :: (HasCallStack, MonadIO m) => SelectionData -> Text -> Int32 -> m Bool

-- | Requests the contents of the clipboard as image. When the image is
--   later received, it will be converted to a <a>Pixbuf</a>, and
--   <i><tt>callback</tt></i> will be called.
--   
--   The <i><tt>pixbuf</tt></i> parameter to <i><tt>callback</tt></i> will
--   contain the resulting <a>Pixbuf</a> if the request succeeded, or
--   <a>Nothing</a> if it failed. This could happen for various reasons, in
--   particular if the clipboard was empty or if the contents of the
--   clipboard could not be converted into an image.
--   
--   <i>Since: 2.6</i>
clipboardRequestImage :: (HasCallStack, MonadIO m, IsClipboard a) => a -> ClipboardImageReceivedFunc -> m ()

-- | Requests the contents of clipboard as the given target. When the
--   results of the result are later received the supplied callback will be
--   called.
clipboardRequestContents :: (HasCallStack, MonadIO m, IsClipboard a) => a -> Atom -> ClipboardReceivedFunc -> m ()

-- | Requests the contents of the clipboard as rich text. When the rich
--   text is later received, <i><tt>callback</tt></i> will be called.
--   
--   The <i><tt>text</tt></i> parameter to <i><tt>callback</tt></i> will
--   contain the resulting rich text if the request succeeded, or
--   <a>Nothing</a> if it failed. The <i><tt>length</tt></i> parameter will
--   contain <i><tt>text</tt></i>’s length. This function can fail for
--   various reasons, in particular if the clipboard was empty or if the
--   contents of the clipboard could not be converted into rich text form.
--   
--   <i>Since: 2.10</i>
clipboardRequestRichText :: (HasCallStack, MonadIO m, IsClipboard a, IsTextBuffer b) => a -> b -> ClipboardRichTextReceivedFunc -> m ()

-- | Requests the contents of the clipboard as list of supported targets.
--   When the list is later received, <i><tt>callback</tt></i> will be
--   called.
--   
--   The <i><tt>targets</tt></i> parameter to <i><tt>callback</tt></i> will
--   contain the resulting targets if the request succeeded, or
--   <a>Nothing</a> if it failed.
--   
--   <i>Since: 2.4</i>
clipboardRequestTargets :: (HasCallStack, MonadIO m, IsClipboard a) => a -> ClipboardTargetsReceivedFunc -> m ()

-- | Requests the contents of the clipboard as text. When the text is later
--   received, it will be converted to UTF-8 if necessary, and
--   <i><tt>callback</tt></i> will be called.
--   
--   The <i><tt>text</tt></i> parameter to <i><tt>callback</tt></i> will
--   contain the resulting text if the request succeeded, or <a>Nothing</a>
--   if it failed. This could happen for various reasons, in particular if
--   the clipboard was empty or if the contents of the clipboard could not
--   be converted into text form.
clipboardRequestText :: (HasCallStack, MonadIO m, IsClipboard a) => a -> ClipboardTextReceivedFunc -> m ()

-- | Requests the contents of the clipboard as URIs. When the URIs are
--   later received <i><tt>callback</tt></i> will be called.
--   
--   The <i><tt>uris</tt></i> parameter to <i><tt>callback</tt></i> will
--   contain the resulting array of URIs if the request succeeded, or
--   <a>Nothing</a> if it failed. This could happen for various reasons, in
--   particular if the clipboard was empty or if the contents of the
--   clipboard could not be converted into URI form.
--   
--   <i>Since: 2.14</i>
clipboardRequestUris :: (HasCallStack, MonadIO m, IsClipboard a) => a -> ClipboardURIReceivedFunc -> m ()

-- | Adds rule to a filter that allows files based on a custom callback
--   function. The bitfield <i><tt>needed</tt></i> which is passed in
--   provides information about what sorts of information that the filter
--   function needs; this allows GTK+ to avoid retrieving expensive
--   information when it isn’t needed by the filter.
--   
--   <i>Since: 2.4</i>
fileFilterAddCustom :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> [FileFilterFlags] -> FileFilterFunc -> m ()

-- | Binds <i><tt>model</tt></i> to <i><tt>box</tt></i>.
--   
--   If <i><tt>box</tt></i> was already bound to a model, that previous
--   binding is destroyed.
--   
--   The contents of <i><tt>box</tt></i> are cleared and then filled with
--   widgets that represent items from <i><tt>model</tt></i>.
--   <i><tt>box</tt></i> is updated whenever <i><tt>model</tt></i> changes.
--   If <i><tt>model</tt></i> is <a>Nothing</a>, <i><tt>box</tt></i> is
--   left empty.
--   
--   It is undefined to add or remove widgets directly (for example, with
--   <a>flowBoxInsert</a> or <a>containerAdd</a>) while <i><tt>box</tt></i>
--   is bound to a model.
--   
--   Note that using a model is incompatible with the filtering and sorting
--   functionality in GtkFlowBox. When using a model, filtering and sorting
--   should be implemented by the model.
--   
--   <i>Since: 3.18</i>
flowBoxBindModel :: (HasCallStack, MonadIO m, IsFlowBox a, IsListModel b) => a -> Maybe b -> FlowBoxCreateWidgetFunc -> m ()

-- | Calls a function for each selected child.
--   
--   Note that the selection cannot be modified from within this function.
--   
--   <i>Since: 3.12</i>
flowBoxSelectedForeach :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> FlowBoxForeachFunc -> m ()

-- | Adds a filter function that decides which fonts to display in the font
--   chooser.
--   
--   <i>Since: 3.2</i>
fontChooserSetFilterFunc :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Maybe FontFilterFunc -> m ()

-- | Calls a function for each selected icon. Note that the model or
--   selection cannot be modified from within this function.
--   
--   <i>Since: 2.6</i>
iconViewSelectedForeach :: (HasCallStack, MonadIO m, IsIconView a) => a -> IconViewForeachFunc -> m ()

-- | Binds <i><tt>model</tt></i> to <i><tt>box</tt></i>.
--   
--   If <i><tt>box</tt></i> was already bound to a model, that previous
--   binding is destroyed.
--   
--   The contents of <i><tt>box</tt></i> are cleared and then filled with
--   widgets that represent items from <i><tt>model</tt></i>.
--   <i><tt>box</tt></i> is updated whenever <i><tt>model</tt></i> changes.
--   If <i><tt>model</tt></i> is <a>Nothing</a>, <i><tt>box</tt></i> is
--   left empty.
--   
--   It is undefined to add or remove widgets directly (for example, with
--   <a>listBoxInsert</a> or <a>containerAdd</a>) while <i><tt>box</tt></i>
--   is bound to a model.
--   
--   Note that using a model is incompatible with the filtering and sorting
--   functionality in GtkListBox. When using a model, filtering and sorting
--   should be implemented by the model.
--   
--   <i>Since: 3.16</i>
listBoxBindModel :: (HasCallStack, MonadIO m, IsListBox a, IsListModel b) => a -> Maybe b -> Maybe ListBoxCreateWidgetFunc -> m ()

-- | Recursively shows a widget, and any child widgets (if the widget is a
--   container).
widgetShowAll :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Calls a function for each selected child.
--   
--   Note that the selection cannot be modified from within this function.
--   
--   <i>Since: 3.14</i>
listBoxSelectedForeach :: (HasCallStack, MonadIO m, IsListBox a) => a -> ListBoxForeachFunc -> m ()

-- | Sets the current header of the <i><tt>row</tt></i>. This is only
--   allowed to be called from a <a>ListBoxUpdateHeaderFunc</a>. It will
--   replace any existing header in the row, and be shown in front of the
--   row in the listbox.
--   
--   <i>Since: 3.10</i>
listBoxRowSetHeader :: (HasCallStack, MonadIO m, IsListBoxRow a, IsWidget b) => a -> Maybe b -> m ()

-- | Attaches the menu to the widget and provides a callback function that
--   will be invoked when the menu calls <a>menuDetach</a> during its
--   destruction.
--   
--   If the menu is attached to the widget then it will be destroyed when
--   the widget is destroyed, as if it was a child widget. An attached menu
--   will also move between screens correctly if the widgets moves between
--   screens.
menuAttachToWidget :: (HasCallStack, MonadIO m, IsMenu a, IsWidget b) => a -> b -> Maybe MenuDetachFunc -> m ()

-- | Displays a menu and makes it available for selection.
--   
--   Applications can use this function to display context-sensitive menus,
--   and will typically supply <a>Nothing</a> for the
--   <i><tt>parentMenuShell</tt></i>, <i><tt>parentMenuItem</tt></i>,
--   <i><tt>func</tt></i> and <i><tt>data</tt></i> parameters. The default
--   menu positioning function will position the menu at the current mouse
--   cursor position.
--   
--   The <i><tt>button</tt></i> parameter should be the mouse button
--   pressed to initiate the menu popup. If the menu popup was initiated by
--   something other than a mouse button press, such as a mouse button
--   release or a keypress, <i><tt>button</tt></i> should be 0.
--   
--   The <i><tt>activateTime</tt></i> parameter is used to conflict-resolve
--   initiation of concurrent requests for mouse/keyboard grab requests. To
--   function properly, this needs to be the timestamp of the user event
--   (such as a mouse click or key press) that caused the initiation of the
--   popup. Only if no such event is available, <a>getCurrentEventTime</a>
--   can be used instead.
--   
--   Note that this function does not work very well on GDK backends that
--   do not have global coordinates, such as Wayland or Mir. You should
--   probably use one of the gtk_menu_popup_at_ variants, which do not have
--   this problem.
menuPopup :: (HasCallStack, MonadIO m, IsMenu a, IsWidget b, IsWidget c) => a -> Maybe b -> Maybe c -> Maybe MenuPositionFunc -> Word32 -> Word32 -> m ()

-- | Informs GTK+ on which monitor a menu should be popped up. See
--   <a>monitorGetGeometry</a>.
--   
--   This function should be called from a <a>MenuPositionFunc</a> if the
--   menu should not appear on the same monitor as the pointer. This
--   information can’t be reliably inferred from the coordinates returned
--   by a <a>MenuPositionFunc</a>, since, for very long menus, these
--   coordinates may extend beyond the monitor boundaries or even the
--   screen boundaries.
--   
--   <i>Since: 2.4</i>
menuSetMonitor :: (HasCallStack, MonadIO m, IsMenu a) => a -> Int32 -> m ()

-- | Runs a page setup dialog, letting the user modify the values from
--   <i><tt>pageSetup</tt></i>.
--   
--   In contrast to <a>printRunPageSetupDialog</a>, this function returns
--   after showing the page setup dialog on platforms that support this,
--   and calls <i><tt>doneCb</tt></i> from a signal handler for the
--   <a>response</a> signal of the dialog.
--   
--   <i>Since: 2.10</i>
printRunPageSetupDialogAsync :: (HasCallStack, MonadIO m, IsWindow a, IsPageSetup b, IsPrintSettings c) => Maybe a -> Maybe b -> c -> PageSetupDoneFunc -> m ()

-- | Adds a rule to a filter that allows resources based on a custom
--   callback function. The bitfield <i><tt>needed</tt></i> which is passed
--   in provides information about what sorts of information that the
--   filter function needs; this allows GTK+ to avoid retrieving expensive
--   information when it isn’t needed by the filter.
--   
--   <i>Since: 2.10</i>
recentFilterAddCustom :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> [RecentFilterFlags] -> RecentFilterFunc -> m ()

-- | This function serializes the portion of text between
--   <i><tt>start</tt></i> and <i><tt>end</tt></i> in the rich text format
--   represented by <i><tt>format</tt></i>.
--   
--   <i><tt>formats</tt></i> to be used must be registered using
--   <a>textBufferRegisterSerializeFormat</a> or
--   <a>textBufferRegisterSerializeTagset</a> beforehand.
--   
--   <i>Since: 2.10</i>
textBufferSerialize :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextBuffer b) => a -> b -> Atom -> TextIter -> TextIter -> m ByteString

-- | Queues an animation frame update and adds a callback to be called
--   before each frame. Until the tick callback is removed, it will be
--   called frequently (usually at the frame rate of the output device or
--   as quickly as the application can be repainted, whichever is slower).
--   For this reason, is most suitable for handling graphics that change
--   every frame or every few frames. The tick callback does not
--   automatically imply a relayout or repaint. If you want a repaint or
--   relayout, and aren’t changing widget properties that would trigger
--   that (for example, changing the text of a <a>Label</a>), then you will
--   have to call <a>widgetQueueResize</a> or <a>widgetQueueDrawArea</a>
--   yourself.
--   
--   <a>frameClockGetFrameTime</a> should generally be used for timing
--   continuous animations and
--   <a>frameTimingsGetPredictedPresentationTime</a> if you are trying to
--   display isolated frames at particular times.
--   
--   This is a more convenient alternative to connecting directly to the
--   <a>FrameClock::update</a> signal of <a>FrameClock</a>, since you don't
--   have to worry about when a <a>FrameClock</a> is assigned to a widget.
--   
--   <i>Since: 3.8</i>
widgetAddTickCallback :: (HasCallStack, MonadIO m, IsWidget a) => a -> TickCallback -> m Word32

-- | Sets the <a>TreeCellDataFunc</a> to use for the column. This function
--   is used instead of the standard attributes mapping for setting the
--   column value, and should set the value of <i><tt>treeColumn</tt></i>'s
--   cell renderer as appropriate. <i><tt>func</tt></i> may be
--   <a>Nothing</a> to remove an older one.
treeViewColumnSetCellDataFunc :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> Maybe TreeCellDataFunc -> m ()

-- | Calls func on each node in model in a depth-first fashion.
--   
--   If <i><tt>func</tt></i> returns <a>True</a>, then the tree ceases to
--   be walked, and <a>treeModelForeach</a> returns.
treeModelForeach :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeModelForeachFunc -> m ()

-- | Calls a function for each selected node. Note that you cannot modify
--   the tree or selection from within this function. As a result,
--   <a>treeSelectionGetSelectedRows</a> might be more useful.
treeSelectionSelectedForeach :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreeSelectionForeachFunc -> m ()

-- | Sets the selection function.
--   
--   If set, this function is called before any node is selected or
--   unselected, giving some control over which nodes are selected. The
--   select function should return <a>True</a> if the state of the node may
--   be toggled, and <a>False</a> if the state of the node should be left
--   unchanged.
treeSelectionSetSelectFunction :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> Maybe TreeSelectionFunc -> m ()

-- | Calls <i><tt>func</tt></i> on all expanded rows.
treeViewMapExpandedRows :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreeViewMappingFunc -> m ()

-- | Loops over the entries in the accelerator map whose accel path doesn’t
--   match any of the filters added with <a>accelMapAddFilter</a>, and
--   execute <i><tt>foreachFunc</tt></i> on each. The signature of
--   <i><tt>foreachFunc</tt></i> is that of <a>AccelMapForeach</a>, the
--   <i><tt>changed</tt></i> parameter indicates whether this accelerator
--   was changed during runtime (thus, would need saving during an
--   accelerator map dump).
accelMapForeach :: (HasCallStack, MonadIO m) => Ptr () -> AccelMapForeach -> m ()

-- | Loops over all entries in the accelerator map, and execute
--   <i><tt>foreachFunc</tt></i> on each. The signature of
--   <i><tt>foreachFunc</tt></i> is that of <a>AccelMapForeach</a>, the
--   <i><tt>changed</tt></i> parameter indicates whether this accelerator
--   was changed during runtime (thus, would need saving during an
--   accelerator map dump).
accelMapForeachUnfiltered :: (HasCallStack, MonadIO m) => Ptr () -> AccelMapForeach -> m ()

-- | Sets the <a>CellLayoutDataFunc</a> to use for
--   <i><tt>cellLayout</tt></i>.
--   
--   This function is used instead of the standard attributes mapping for
--   setting the column value, and should set the value of
--   <i><tt>cellLayout</tt></i>’s cell renderer(s) as appropriate.
--   
--   <i><tt>func</tt></i> may be <a>Nothing</a> to remove a previously set
--   function.
--   
--   <i>Since: 2.4</i>
cellLayoutSetCellDataFunc :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Maybe CellLayoutDataFunc -> m ()

-- | Sets the match function for <i><tt>completion</tt></i> to be
--   <i><tt>func</tt></i>. The match function is used to determine if a row
--   should or should not be in the completion list.
--   
--   <i>Since: 2.4</i>
entryCompletionSetMatchFunc :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> EntryCompletionMatchFunc -> m ()

-- | Calls <i><tt>func</tt></i> on each tag in <i><tt>table</tt></i>, with
--   user data <i><tt>data</tt></i>. Note that the table may not be
--   modified while iterating over it (you can’t add/remove tags).
textTagTableForeach :: (HasCallStack, MonadIO m, IsTextTagTable a) => a -> TextTagTableForeach -> m ()

-- | Obtains the frame clock for a widget. The frame clock is a global
--   “ticker” that can be used to drive animations and repaints. The most
--   common reason to get the frame clock is to call
--   <a>frameClockGetFrameTime</a>, in order to get a time to use for
--   animating. For example you might record the start of the animation
--   with an initial value from <a>frameClockGetFrameTime</a>, and then
--   update the animation by calling <a>frameClockGetFrameTime</a> again
--   during each repaint.
--   
--   <a>frameClockRequestPhase</a> will result in a new frame on the clock,
--   but won’t necessarily repaint any widgets. To repaint a widget, you
--   have to use <a>widgetQueueDraw</a> which invalidates the widget (thus
--   scheduling it to receive a draw on the next frame).
--   <a>widgetQueueDraw</a> will also end up requesting a frame on the
--   appropriate frame clock.
--   
--   A widget’s frame clock will not change while the widget is mapped.
--   Reparenting a widget (which implies a temporary unmap) can change the
--   widget’s frame clock.
--   
--   Unrealized widgets do not have a frame clock.
--   
--   <i>Since: 3.8</i>
widgetGetFrameClock :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe FrameClock)

-- | Sets the comparison function used when sorting to be
--   <i><tt>sortFunc</tt></i>. If the current sort column id of
--   <i><tt>sortable</tt></i> is the same as <i><tt>sortColumnId</tt></i>,
--   then the model will sort using this function.
treeSortableSetSortFunc :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> Int32 -> TreeIterCompareFunc -> m ()

-- | Sets the visible function used when filtering the
--   <i><tt>filter</tt></i> to be <i><tt>func</tt></i>. The function should
--   return <a>True</a> if the given row should be visible and <a>False</a>
--   otherwise.
--   
--   If the condition calculated by the function changes over time (e.g.
--   because it depends on some global parameters), you must call
--   <a>treeModelFilterRefilter</a> to keep the visibility information of
--   the model up-to-date.
--   
--   Note that <i><tt>func</tt></i> is called whenever a row is inserted,
--   when it may still be empty. The visible function should therefore take
--   special care of empty rows, like in the example below.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   static gboolean
--   visible_func (GtkTreeModel *model,
--                 GtkTreeIter  *iter,
--                 gpointer      data)
--   {
--     // Visible if row is non-empty and first column is “HI”
--     gchar *str;
--     gboolean visible = FALSE;
--   
--     gtk_tree_model_get (model, iter, 0, &amp;str, -1);
--     if (str &amp;&amp; strcmp (str, "HI") == 0)
--       visible = TRUE;
--     g_free (str);
--   
--     return visible;
--   }
--   </pre>
--   
--   Note that <a>treeModelFilterSetVisibleFunc</a> or
--   <a>treeModelFilterSetVisibleColumn</a> can only be called once for a
--   given filter model.
--   
--   <i>Since: 2.4</i>
treeModelFilterSetVisibleFunc :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreeModelFilterVisibleFunc -> m ()

-- | Sets <i><tt>column</tt></i> as the column where the interactive search
--   code should search in for the current model.
--   
--   If the search column is set, users can use the
--   “start-interactive-search” key binding to bring up search popup. The
--   enable-search property controls whether simply typing text will also
--   start an interactive search.
--   
--   Note that <i><tt>column</tt></i> refers to a column of the current
--   model. The search column is reset to -1 when the model is changed.
treeViewSetSearchColumn :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> m ()

-- | Sets the compare function for the interactive search capabilities;
--   note that somewhat like <tt><i>strcmp()</i></tt> returning 0 for
--   equality <a>TreeViewSearchEqualFunc</a> returns <a>False</a> on
--   matches.
treeViewSetSearchEqualFunc :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreeViewSearchEqualFunc -> m ()

-- | Updates the style context of <i><tt>widget</tt></i> and all
--   descendants by updating its widget path. <tt><i>GtkContainers</i></tt>
--   may want to use this on a child when reordering it in a way that a
--   different style might apply to it. See also
--   <a>containerGetPathForChild</a>.
--   
--   <i>Since: 3.0</i>
widgetResetStyle :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Adds a style class to <i><tt>context</tt></i>, so posterior calls to
--   <tt><i>gtk_style_context_get()</i></tt> or any of the gtk_render_*()
--   functions will make use of this new class for styling.
--   
--   In the CSS file format, a <a>Entry</a> defining a “search” class,
--   would be matched by:
--   
--   <pre>
--    &lt;!-- language="CSS" --&gt;
--   entry.search { ... }
--   </pre>
--   
--   While any widget defining a “search” class would be matched by: &gt;
--   <a>language="CSS" --</a> &gt;.search { ... }
--   
--   <i>Since: 3.0</i>
styleContextAddClass :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m ()

-- | Adds a region to <i><tt>context</tt></i>, so posterior calls to
--   <tt><i>gtk_style_context_get()</i></tt> or any of the gtk_render_*()
--   functions will make use of this new region for styling.
--   
--   In the CSS file format, a <a>TreeView</a> defining a “row” region,
--   would be matched by:
--   
--   <pre>
--    &lt;!-- language="CSS" --&gt;
--   treeview row { ... }
--   </pre>
--   
--   Pseudo-classes are used for matching <i><tt>flags</tt></i>, so the two
--   following rules: &gt; <a>language="CSS" --</a> &gt;treeview
--   row:nth-child(even) { ... } &gt;treeview row:nth-child(odd) { ... }
--   
--   would apply to even and odd rows, respectively.
--   
--   Region names must only contain lowercase letters and “-”, starting
--   always with a lowercase letter.
--   
--   <i>Since: 3.0</i>
styleContextAddRegion :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> [RegionFlags] -> m ()

-- | Adds the <i><tt>callbackSymbol</tt></i> to the scope of
--   <i><tt>builder</tt></i> under the given <i><tt>callbackName</tt></i>.
--   
--   Using this function overrides the behavior of
--   <a>builderConnectSignals</a> for any callback symbols that are added.
--   Using this method allows for better encapsulation as it does not
--   require that callback symbols be declared in the global namespace.
--   
--   <i>Since: 3.10</i>
builderAddCallbackSymbol :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> Callback -> m ()

-- | Fetch an object build from the template XML for
--   <i><tt>widgetType</tt></i> in this <i><tt>widget</tt></i> instance.
--   
--   This will only report children which were previously declared with
--   <a>widgetClassBindTemplateChildFull</a> or one of its variants.
--   
--   This function is only meant to be called for code which is private to
--   the <i><tt>widgetType</tt></i> which declared the child and is meant
--   for language bindings which cannot easily make use of the GObject
--   structure offsets.
widgetGetTemplateChild :: (HasCallStack, MonadIO m, IsWidget a) => a -> GType -> Text -> m Object

-- | Creates and initializes child widgets defined in templates. This
--   function must be called in the instance initializer for any class
--   which assigned itself a template using <a>widgetClassSetTemplate</a>
--   
--   It is important to call this function in the instance initializer of a
--   <a>Widget</a> subclass and not in
--   <a>Object</a>.<tt><i>constructed</i></tt>() or
--   <a>Object</a>.<tt><i>constructor</i></tt>() for two reasons.
--   
--   One reason is that generally derived widgets will assume that parent
--   class composite widgets have been created in their instance
--   initializers.
--   
--   Another reason is that when calling <tt><i>g_object_new()</i></tt> on
--   a widget with composite templates, it’s important to build the
--   composite widgets before the construct properties are set. Properties
--   passed to <tt><i>g_object_new()</i></tt> should take precedence over
--   properties set in the private template XML.
--   
--   <i>Since: 3.10</i>
widgetInitTemplate :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Lets a set of row reference created by <a>treeRowReferenceNewProxy</a>
--   know that the model emitted the <a>TreeModel::rowInserted</a> signal.
treeRowReferenceInserted :: (HasCallStack, MonadIO m, IsObject a) => a -> TreePath -> m ()

-- | Lets a set of row reference created by <a>treeRowReferenceNewProxy</a>
--   know that the model emitted the <a>TreeModel::rowDeleted</a> signal.
treeRowReferenceDeleted :: (HasCallStack, MonadIO m, IsObject a) => a -> TreePath -> m ()

-- | Like <a>textBufferInsert</a>, but the insertion will not occur if
--   <i><tt>iter</tt></i> is at a non-editable location in the buffer.
--   Usually you want to prevent insertions at ineditable locations if the
--   insertion results from a user action (is interactive).
--   
--   <i><tt>defaultEditable</tt></i> indicates the editability of text that
--   doesn't have a tag affecting editability applied to it. Typically the
--   result of <a>textViewGetEditable</a> is appropriate here.
textBufferInsertInteractive :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> Text -> Int32 -> Bool -> m Bool

-- | Obtains a copy of the default text attributes. These are the
--   attributes used for text unless a tag overrides them. You’d typically
--   pass the default attributes in to <a>textIterGetAttributes</a> in
--   order to get the attributes in effect at a given text position.
--   
--   The return value is a copy owned by the caller of this function, and
--   should be freed with <a>textAttributesUnref</a>.
textViewGetDefaultAttributes :: (HasCallStack, MonadIO m, IsTextView a) => a -> m TextAttributes

-- | Returns the <a>Language</a> for the default language currently in
--   effect. (Note that this can change over the life of an application.)
--   The default language is derived from the current locale. It
--   determines, for example, whether GTK+ uses the right-to-left or
--   left-to-right text direction.
--   
--   This function is equivalent to <a>languageGetDefault</a>. See that
--   function for details.
getDefaultLanguage :: (HasCallStack, MonadIO m) => m Language

-- | Initializes <i><tt>iter</tt></i> to a position
--   <i><tt>charOffset</tt></i> chars from the start of the entire buffer.
--   If <i><tt>charOffset</tt></i> is -1 or greater than the number of
--   characters in the buffer, <i><tt>iter</tt></i> is initialized to the
--   end iterator, the iterator one past the last valid character in the
--   buffer.
textBufferGetIterAtOffset :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> m TextIter

-- | This function registers a rich text serialization
--   <i><tt>function</tt></i> along with its <i><tt>mimeType</tt></i> with
--   the passed <i><tt>buffer</tt></i>.
--   
--   <i>Since: 2.10</i>
textBufferRegisterSerializeFormat :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> TextBufferSerializeFunc -> m Atom

-- | This function registers a rich text deserialization
--   <i><tt>function</tt></i> along with its <i><tt>mimeType</tt></i> with
--   the passed <i><tt>buffer</tt></i>.
--   
--   <i>Since: 2.10</i>
textBufferRegisterDeserializeFormat :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> FunPtr C_TextBufferDeserializeFunc -> m Atom

-- | Looks up and resolves a color name in the <i><tt>context</tt></i>
--   color map.
styleContextLookupColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m (Bool, RGBA)

-- | Returns the symbolic color that is mapped to <i><tt>name</tt></i>.
--   
--   <i>Since: 3.0</i>
stylePropertiesLookupColor :: (HasCallStack, MonadIO m, IsStyleProperties a) => a -> Text -> m SymbolicColor

-- | A convenience function that uses the theme engine and style settings
--   for <i><tt>widget</tt></i> to look up <i><tt>stockId</tt></i> and
--   render it to a pixbuf. <i><tt>stockId</tt></i> should be a stock icon
--   ID such as <a>STOCK_OPEN</a> or <a>STOCK_OK</a>. <i><tt>size</tt></i>
--   should be a size such as <tt><i>GTK_ICON_SIZE_MENU</i></tt>.
--   
--   The pixels in the returned <a>Pixbuf</a> are shared with the rest of
--   the application and should not be modified. The pixbuf should be freed
--   after use with <a>objectUnref</a>.
--   
--   <i>Since: 3.0</i>
widgetRenderIconPixbuf :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> Int32 -> m (Maybe Pixbuf)

-- | Renders the icon specified by <i><tt>source</tt></i> at the given
--   <i><tt>size</tt></i> according to the given parameters and returns the
--   result in a pixbuf.
styleRenderIcon :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> IconSource -> TextDirection -> StateType -> Int32 -> Maybe b -> Maybe Text -> m Pixbuf

-- | A convenience function that uses the theme settings for
--   <i><tt>widget</tt></i> to look up <i><tt>stockId</tt></i> and render
--   it to a pixbuf. <i><tt>stockId</tt></i> should be a stock icon ID such
--   as <a>STOCK_OPEN</a> or <a>STOCK_OK</a>. <i><tt>size</tt></i> should
--   be a size such as <tt><i>GTK_ICON_SIZE_MENU</i></tt>.
--   <i><tt>detail</tt></i> should be a string that identifies the widget
--   or code doing the rendering, so that theme engines can special-case
--   rendering for that widget or code.
--   
--   The pixels in the returned <a>Pixbuf</a> are shared with the rest of
--   the application and should not be modified. The pixbuf should be freed
--   after use with <a>objectUnref</a>.
widgetRenderIcon :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> Int32 -> Maybe Text -> m (Maybe Pixbuf)

-- | Renders the icon specified by <i><tt>source</tt></i> at the given
--   <i><tt>size</tt></i>, returning the result in a pixbuf.
--   
--   <i>Since: 3.0</i>
renderIconPixbuf :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> IconSource -> Int32 -> m Pixbuf

-- | Makes <i><tt>widget</tt></i> the current grabbed widget.
--   
--   This means that interaction with other widgets in the same application
--   is blocked and mouse as well as keyboard events are delivered to this
--   widget.
--   
--   If <i><tt>widget</tt></i> is not sensitive, it is not set as the
--   current grabbed widget and this function does nothing.
widgetGrabAdd :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Destroys a widget.
--   
--   When a widget is destroyed all references it holds on other objects
--   will be released:
--   
--   <ul>
--   <li>if the widget is inside a container, it will be removed from its
--   parent</li>
--   <li>if the widget is a container, all its children will be destroyed,
--   recursively</li>
--   <li>if the widget is a top level, it will be removed from the list of
--   top level widgets that GTK+ maintains internally</li>
--   </ul>
--   
--   It's expected that all references held on the widget will also be
--   released; you should connect to the <a>Widget::destroy</a> signal if
--   you hold a reference to <i><tt>widget</tt></i> and you wish to remove
--   it when this function is called. It is not necessary to do so if you
--   are implementing a <a>Container</a>, as you'll be able to use the
--   <a>ContainerClass</a>.<tt><i>remove</i></tt>() virtual function for
--   that.
--   
--   It's important to notice that <a>widgetDestroy</a> will only cause the
--   <i><tt>widget</tt></i> to be finalized if no additional references,
--   acquired using <a>objectRef</a>, are held on it. In case additional
--   references are in place, the <i><tt>widget</tt></i> will be in an
--   "inert" state after calling this function; <i><tt>widget</tt></i> will
--   still point to valid memory, allowing you to release the references
--   you hold, but you may not query the widget's own state.
--   
--   You should typically call this function on top level widgets, and
--   rarely on child widgets.
--   
--   See also: <a>containerRemove</a>
widgetDestroy :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Specifies whether <i><tt>widget</tt></i> will be treated as the
--   default widget within its toplevel when it has the focus, even if
--   another widget is the default.
--   
--   See <a>widgetGrabDefault</a> for details about the meaning of
--   “default”.
--   
--   <i>Since: 2.18</i>
widgetSetReceivesDefault :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Finds the first accelerator in any <a>AccelGroup</a> attached to
--   <i><tt>object</tt></i> that matches <i><tt>accelKey</tt></i> and
--   <i><tt>accelMods</tt></i>, and activates that accelerator.
accelGroupsActivate :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> [ModifierType] -> m Bool

-- | Flags a widget to be displayed. Any widget that isn’t shown will not
--   appear on the screen. If you want to show all the widgets in a
--   container, it’s easier to call <a>widgetShowAll</a> on the container,
--   instead of individually showing the widgets.
--   
--   Remember that you have to show the containers containing a widget, in
--   addition to the widget itself, before it will appear onscreen.
--   
--   When a toplevel container is shown, it is immediately realized and
--   mapped; other shown widgets are realized and mapped when their
--   toplevel container is realized and mapped.
widgetShow :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Sets the minimum size of a widget; that is, the widget’s size request
--   will be at least <i><tt>width</tt></i> by <i><tt>height</tt></i>. You
--   can use this function to force a widget to be larger than it normally
--   would be.
--   
--   In most cases, <a>windowSetDefaultSize</a> is a better choice for
--   toplevel windows than this function; setting the default size will
--   still allow users to shrink the window. Setting the size request will
--   force them to leave the window at least as large as the size request.
--   When dealing with window sizes, <a>windowSetGeometryHints</a> can be a
--   useful function as well.
--   
--   Note the inherent danger of setting any fixed size - themes,
--   translations into other languages, different fonts, and user action
--   can all change the appropriate size for a given widget. So, it's
--   basically impossible to hardcode a size that will always be correct.
--   
--   The size request of a widget is the smallest size a widget can accept
--   while still functioning well and drawing itself correctly. However in
--   some strange cases a widget may be allocated less than its requested
--   size, and in many cases a widget may be allocated more space than it
--   requested.
--   
--   If the size request in a given direction is -1 (unset), then the
--   “natural” size request of the widget will be used instead.
--   
--   The size request set here does not include any margin from the
--   <a>Widget</a> properties margin-left, margin-right, margin-top, and
--   margin-bottom, but it does include pretty much all other padding or
--   border properties set by any subclass of <a>Widget</a>.
widgetSetSizeRequest :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> Int32 -> m ()

-- | Remove a window from <i><tt>application</tt></i>.
--   
--   If <i><tt>window</tt></i> belongs to <i><tt>application</tt></i> then
--   this call is equivalent to setting the <a>Window:application</a>
--   property of <i><tt>window</tt></i> to <a>Nothing</a>.
--   
--   The application may stop running as a result of a call to this
--   function.
--   
--   <i>Since: 3.0</i>
applicationRemoveWindow :: (HasCallStack, MonadIO m, IsApplication a, IsWindow b) => a -> b -> m ()

-- | Adds a window to <i><tt>application</tt></i>.
--   
--   This call can only happen after the <i><tt>application</tt></i> has
--   started; typically, you should add new application windows in response
--   to the emission of the <a>Application::activate</a> signal.
--   
--   This call is equivalent to setting the <a>Window:application</a>
--   property of <i><tt>window</tt></i> to <i><tt>application</tt></i>.
--   
--   Normally, the connection between the application and the window will
--   remain until the window is destroyed, but you can explicitly remove it
--   with <a>applicationRemoveWindow</a>.
--   
--   GTK+ will keep the <i><tt>application</tt></i> running as long as it
--   has any windows.
--   
--   <i>Since: 3.0</i>
applicationAddWindow :: (HasCallStack, MonadIO m, IsApplication a, IsWindow b) => a -> b -> m ()

-- | Causes <i><tt>widget</tt></i> to become the default widget.
--   <i><tt>widget</tt></i> must be able to be a default widget; typically
--   you would ensure this yourself by calling <a>widgetSetCanDefault</a>
--   with a <a>True</a> value. The default widget is activated when the
--   user presses Enter in a window. Default widgets must be activatable,
--   that is, <a>widgetActivate</a> should affect them. Note that
--   <a>Entry</a> widgets require the “activates-default” property set to
--   <a>True</a> before they activate the default widget when Enter is
--   pressed and the <a>Entry</a> is focused.
widgetGrabDefault :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Specifies whether <i><tt>widget</tt></i> can be a default widget. See
--   <a>widgetGrabDefault</a> for details about the meaning of “default”.
--   
--   <i>Since: 2.18</i>
widgetSetCanDefault :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Causes <i><tt>widget</tt></i> to have the keyboard focus for the
--   <a>Window</a> it's inside. <i><tt>widget</tt></i> must be a focusable
--   widget, such as a <a>Entry</a>; something like <a>Frame</a> won’t
--   work.
--   
--   More precisely, it must have the <tt><i>GTK_CAN_FOCUS</i></tt> flag
--   set. Use <a>widgetSetCanFocus</a> to modify that flag.
--   
--   The widget also needs to be realized and mapped. This is indicated by
--   the related signals. Grabbing the focus immediately after creating the
--   widget will likely fail and cause critical warnings.
widgetGrabFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Whether <i><tt>widget</tt></i> can rely on having its alpha channel
--   drawn correctly. On X11 this function returns whether a compositing
--   manager is running for <i><tt>widget</tt></i>’s screen.
--   
--   Please note that the semantics of this call will change in the future
--   if used on a widget that has a composited window in its hierarchy (as
--   set by <a>windowSetComposited</a>).
--   
--   <i>Since: 2.10</i>
widgetIsComposited :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Associate <i><tt>accelGroup</tt></i> with <i><tt>window</tt></i>, such
--   that calling <a>accelGroupsActivate</a> on <i><tt>window</tt></i> will
--   activate accelerators in <i><tt>accelGroup</tt></i>.
windowAddAccelGroup :: (HasCallStack, MonadIO m, IsWindow a, IsAccelGroup b) => a -> b -> m ()

-- | Registers a new accelerator with the global accelerator map. This
--   function should only be called once per <i><tt>accelPath</tt></i> with
--   the canonical <i><tt>accelKey</tt></i> and <i><tt>accelMods</tt></i>
--   for this path. To change the accelerator during runtime
--   programatically, use <a>accelMapChangeEntry</a>.
--   
--   Set <i><tt>accelKey</tt></i> and <i><tt>accelMods</tt></i> to 0 to
--   request a removal of the accelerator.
--   
--   Note that <i><tt>accelPath</tt></i> string will be stored in a
--   <tt><i>GQuark</i></tt>. Therefore, if you pass a static string, you
--   can save some memory by interning it first with
--   <a>internStaticString</a>.
accelMapAddEntry :: (HasCallStack, MonadIO m) => Text -> Word32 -> [ModifierType] -> m ()

-- | Set the accelerator path on <i><tt>menuItem</tt></i>, through which
--   runtime changes of the menu item’s accelerator caused by the user can
--   be identified and saved to persistent storage (see <a>accelMapSave</a>
--   on this). To set up a default accelerator for this menu item, call
--   <a>accelMapAddEntry</a> with the same <i><tt>accelPath</tt></i>. See
--   also <a>accelMapAddEntry</a> on the specifics of accelerator paths,
--   and <a>menuSetAccelPath</a> for a more convenient variant of this
--   function.
--   
--   This function is basically a convenience wrapper that handles calling
--   <a>widgetSetAccelPath</a> with the appropriate accelerator group for
--   the menu item.
--   
--   Note that you do need to set an accelerator on the parent menu with
--   <a>menuSetAccelGroup</a> for this to work.
--   
--   Note that <i><tt>accelPath</tt></i> string will be stored in a
--   <tt><i>GQuark</i></tt>. Therefore, if you pass a static string, you
--   can save some memory by interning it first with
--   <a>internStaticString</a>.
menuItemSetAccelPath :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> Maybe Text -> m ()

-- | Sets a focus chain, overriding the one computed automatically by GTK+.
--   
--   In principle each widget in the chain should be a descendant of the
--   container, but this is not enforced by this method, since it’s allowed
--   to set the focus chain before you pack the widgets, or have a widget
--   in the chain that isn’t always packed. The necessary checks are done
--   when the focus chain is actually traversed.
containerSetFocusChain :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> [b] -> m ()

-- | Emits a <a>Widget::childNotify</a> signal for the [child
--   property][child-properties] <i><tt>childProperty</tt></i> on the
--   child.
--   
--   This is an analogue of <a>objectNotify</a> for child properties.
--   
--   Also see <a>widgetChildNotify</a>.
--   
--   <i>Since: 3.2</i>
containerChildNotify :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> b -> Text -> m ()

-- | Removes <i><tt>widget</tt></i> from <i><tt>container</tt></i>.
--   <i><tt>widget</tt></i> must be inside <i><tt>container</tt></i>. Note
--   that <i><tt>container</tt></i> will own a reference to
--   <i><tt>widget</tt></i>, and that this may be the last reference held;
--   so removing a widget from its container can destroy that widget. If
--   you want to use <i><tt>widget</tt></i> again, you need to add a
--   reference to it before removing it from a container, using
--   <a>objectRef</a>. If you don’t want to use <i><tt>widget</tt></i>
--   again it’s usually more efficient to simply destroy it directly using
--   <a>widgetDestroy</a> since this will remove it from the container and
--   help break any circular reference count cycles.
containerRemove :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> b -> m ()

-- | Adds a GTK+ grab on <i><tt>device</tt></i>, so all the events on
--   <i><tt>device</tt></i> and its associated pointer or keyboard (if any)
--   are delivered to <i><tt>widget</tt></i>. If the
--   <i><tt>blockOthers</tt></i> parameter is <a>True</a>, any other
--   devices will be unable to interact with <i><tt>widget</tt></i> during
--   the grab.
--   
--   <i>Since: 3.0</i>
deviceGrabAdd :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> Bool -> m ()

-- | Appends the image targets supported by <a>SelectionData</a> to the
--   target list. All targets are added with the same <i><tt>info</tt></i>.
--   
--   <i>Since: 2.6</i>
targetListAddImageTargets :: (HasCallStack, MonadIO m) => TargetList -> Word32 -> Bool -> m ()

-- | Appends the text targets supported by <a>SelectionData</a> to the
--   target list. All targets are added with the same <i><tt>info</tt></i>.
--   
--   <i>Since: 2.6</i>
targetListAddTextTargets :: (HasCallStack, MonadIO m) => TargetList -> Word32 -> m ()

-- | Appends the URI targets supported by <a>SelectionData</a> to the
--   target list. All targets are added with the same <i><tt>info</tt></i>.
--   
--   Since 3.24.37, this includes the application/vnd.portal.files target
--   when possible, to allow sending files between sandboxed apps via the
--   FileTransfer portal.
--   
--   <i>Since: 2.6</i>
targetListAddUriTargets :: (HasCallStack, MonadIO m) => TargetList -> Word32 -> m ()

-- | Processes a single GDK event.
--   
--   This is public only to allow filtering of events between GDK and GTK+.
--   You will not usually need to call this function directly.
--   
--   While you should not call this function directly, you might want to
--   know how exactly events are handled. So here is what this function
--   does with the event:
--   
--   <ol>
--   <li>Compress enter/leave notify events. If the event passed build an
--   enter/leave pair together with the next event (peeked from GDK), both
--   events are thrown away. This is to avoid a backlog of
--   (de-)highlighting widgets crossed by the pointer.</li>
--   <li>Find the widget which got the event. If the widget can’t be
--   determined the event is thrown away unless it belongs to a INCR
--   transaction.</li>
--   <li>Then the event is pushed onto a stack so you can query the
--   currently handled event with <a>getCurrentEvent</a>.</li>
--   <li>The event is sent to a widget. If a grab is active all events for
--   widgets that are not in the contained in the grab widget are sent to
--   the latter with a few exceptions: - Deletion and destruction events
--   are still sent to the event widget for obvious reasons. - Events which
--   directly relate to the visual representation of the event widget. -
--   Leave events are delivered to the event widget if there was an enter
--   event delivered to it before without the paired leave event. - Drag
--   events are not redirected because it is unclear what the semantics of
--   that would be. Another point of interest might be that all key events
--   are first passed through the key snooper functions if there are any.
--   Read the description of <tt><i>gtk_key_snooper_install()</i></tt> if
--   you need this feature.</li>
--   <li>After finishing the delivery the event is popped from the event
--   stack.</li>
--   </ol>
mainDoEvent :: (HasCallStack, MonadIO m) => Event -> m ()

-- | Returns the state used for style matching.
--   
--   This method should only be used to retrieve the <a>StateFlags</a> to
--   pass to <a>StyleContext</a> methods, like
--   <a>styleContextGetPadding</a>. If you need to retrieve the current
--   state of a <a>Widget</a>, use <a>widgetGetStateFlags</a>.
--   
--   <i>Since: 3.0</i>
styleContextGetState :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m [StateFlags]

-- | Automatically assign an object declared in the class template XML to
--   be set to a location on a freshly built instance’s private data, or
--   alternatively accessible via <a>widgetGetTemplateChild</a>.
--   
--   The struct can point either into the public instance, then you should
--   use G_STRUCT_OFFSET(WidgetType, member) for
--   <i><tt>structOffset</tt></i>, or in the private struct, then you
--   should use G_PRIVATE_OFFSET(WidgetType, member).
--   
--   An explicit strong reference will be held automatically for the
--   duration of your instance’s life cycle, it will be released
--   automatically when <a>ObjectClass</a>.<tt><i>dispose</i></tt>() runs
--   on your instance and if a <i><tt>structOffset</tt></i> that is != 0 is
--   specified, then the automatic location in your instance public or
--   private data will be set to <a>Nothing</a>. You can however access an
--   automated child pointer the first time your classes
--   <a>ObjectClass</a>.<tt><i>dispose</i></tt>() runs, or alternatively in
--   <a>WidgetClass</a>.<tt><i>destroy</i></tt>().
--   
--   If <i><tt>internalChild</tt></i> is specified,
--   <a>BuildableIface</a>.<tt><i>get_internal_child</i></tt>() will be
--   automatically implemented by the <a>Widget</a> class so there is no
--   need to implement it manually.
--   
--   The wrapper macros
--   <tt><i>gtk_widget_class_bind_template_child()</i></tt>,
--   <tt><i>gtk_widget_class_bind_template_child_internal()</i></tt>,
--   <tt><i>gtk_widget_class_bind_template_child_private()</i></tt> and
--   <tt><i>gtk_widget_class_bind_template_child_internal_private()</i></tt>
--   might be more convenient to use.
--   
--   Note that this must be called from a composite widget classes class
--   initializer after calling <a>widgetClassSetTemplate</a>.
--   
--   <i>Since: 3.10</i>
widgetClassBindTemplateChildFull :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> Bool -> Int64 -> m ()

-- | Gets the value of the <a>Window:focusVisible</a> property.
--   
--   <i>Since: 3.2</i>
windowGetFocusVisible :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | This should be called at class initialization time to specify the
--   GtkBuilder XML to be used to extend a widget.
--   
--   For convenience, <a>widgetClassSetTemplateFromResource</a> is also
--   provided.
--   
--   Note that any class that installs templates must call
--   <a>widgetInitTemplate</a> in the widget’s instance initializer.
--   
--   <i>Since: 3.10</i>
widgetClassSetTemplate :: (HasCallStack, MonadIO m) => WidgetClass -> Bytes -> m ()

-- | Installs an accelerator in this group, using an accelerator path to
--   look up the appropriate key and modifiers (see
--   <a>accelMapAddEntry</a>). When <i><tt>accelGroup</tt></i> is being
--   activated in response to a call to <a>accelGroupsActivate</a>,
--   <i><tt>closure</tt></i> will be invoked if the
--   <i><tt>accelKey</tt></i> and <i><tt>accelMods</tt></i> from
--   <a>accelGroupsActivate</a> match the key and modifiers for the path.
--   
--   The signature used for the <i><tt>closure</tt></i> is that of
--   <a>AccelGroupActivate</a>.
--   
--   Note that <i><tt>accelPath</tt></i> string will be stored in a
--   <tt><i>GQuark</i></tt>. Therefore, if you pass a static string, you
--   can save some memory by interning it first with
--   <a>internStaticString</a>.
accelGroupConnectByPath :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> Text -> GClosure b -> m ()

-- | Finds the <a>AccelGroup</a> to which <i><tt>closure</tt></i> is
--   connected; see <a>accelGroupConnect</a>.
accelGroupFromAccelClosure :: (HasCallStack, MonadIO m) => GClosure a -> m (Maybe AccelGroup)

-- | If the label has been set so that it has an mnemonic key (using i.e.
--   <a>labelSetMarkupWithMnemonic</a>, <a>labelSetTextWithMnemonic</a>,
--   <a>labelNewWithMnemonic</a> or the “use_underline” property) the label
--   can be associated with a widget that is the target of the mnemonic.
--   When the label is inside a widget (like a <a>Button</a> or a
--   <a>Notebook</a> tab) it is automatically associated with the correct
--   widget, but sometimes (i.e. when the target is a <a>Entry</a> next to
--   the label) you need to set it explicitly using this function.
--   
--   The target widget will be accelerated by emitting the
--   GtkWidget<a>mnemonicActivate</a> signal on it. The default handler for
--   this signal will activate the widget if there are no mnemonic
--   collisions and toggle focus between the colliding widgets otherwise.
labelSetMnemonicWidget :: (HasCallStack, MonadIO m, IsLabel a, IsWidget b) => a -> Maybe b -> m ()

-- | Returns a newly created widget path representing all the widget
--   hierarchy from the toplevel down to and including
--   <i><tt>child</tt></i>.
containerGetPathForChild :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> b -> m WidgetPath

-- | When a container receives a call to the draw function, it must send
--   synthetic <a>Widget::draw</a> calls to all children that don’t have
--   their own <tt><i>GdkWindows</i></tt>. This function provides a
--   convenient way of doing this. A container, when it receives a call to
--   its <a>Widget::draw</a> function, calls <a>containerPropagateDraw</a>
--   once for each child, passing in the <i><tt>cr</tt></i> the container
--   received.
--   
--   <a>containerPropagateDraw</a> takes care of translating the origin of
--   <i><tt>cr</tt></i>, and deciding whether the draw needs to be sent to
--   the child. It is a convenient and optimized way of getting the same
--   effect as calling <a>widgetDraw</a> on the child directly.
--   
--   In most cases, a container can simply either inherit the
--   <a>Widget::draw</a> implementation from <a>Container</a>, or do some
--   drawing and then chain to the <a>draw</a> implementation from
--   <a>Container</a>.
containerPropagateDraw :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> b -> Context -> m ()

-- | Saves current accelerator specifications (accelerator path, key and
--   modifiers) to <i><tt>fileName</tt></i>. The file is written in a
--   format suitable to be read back in by <a>accelMapLoad</a>.
accelMapSave :: (HasCallStack, MonadIO m) => [Char] -> m ()

-- | Sets the default size of a window. If the window’s “natural” size (its
--   size request) is larger than the default, the default will be ignored.
--   More generally, if the default size does not obey the geometry hints
--   for the window (<a>windowSetGeometryHints</a> can be used to set these
--   explicitly), the default size will be clamped to the nearest permitted
--   size.
--   
--   Unlike <a>widgetSetSizeRequest</a>, which sets a size request for a
--   widget and thus would keep users from shrinking the window, this
--   function only sets the initial size, just as if the user had resized
--   the window themselves. Users can still shrink the window again as they
--   normally would. Setting a default size of -1 means to use the
--   “natural” default size (the size request of the window).
--   
--   For more control over a window’s initial size and how resizing works,
--   investigate <a>windowSetGeometryHints</a>.
--   
--   For some uses, <a>windowResize</a> is a more appropriate function.
--   <a>windowResize</a> changes the current size of the window, rather
--   than the size to be used on initial display. <a>windowResize</a>
--   always affects the window itself, not the geometry widget.
--   
--   The default size of a window only affects the first time a window is
--   shown; if a window is hidden and re-shown, it will remember the size
--   it had prior to hiding, rather than using the default size.
--   
--   Windows can’t actually be 0x0 in size, they must be at least 1x1, but
--   passing 0 for <i><tt>width</tt></i> and <i><tt>height</tt></i> is OK,
--   resulting in a 1x1 default size.
--   
--   If you use this function to reestablish a previously saved window
--   size, note that the appropriate size to save is the one returned by
--   <a>windowGetSize</a>. Using the window allocation directly will not
--   work in all circumstances and can lead to growing or shrinking
--   windows.
windowSetDefaultSize :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> m ()

-- | Sets the text of the tooltip to be <i><tt>markup</tt></i>, which is
--   marked up with the [Pango text markup language][PangoMarkupFormat]. If
--   <i><tt>markup</tt></i> is <a>Nothing</a>, the label will be hidden.
--   
--   <i>Since: 2.12</i>
tooltipSetMarkup :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe Text -> m ()

-- | Sets the text of the tooltip to be <i><tt>text</tt></i>. If
--   <i><tt>text</tt></i> is <a>Nothing</a>, the label will be hidden. See
--   also <a>tooltipSetMarkup</a>.
--   
--   <i>Since: 2.12</i>
tooltipSetText :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe Text -> m ()

-- | Triggers a new tooltip query on <i><tt>display</tt></i>, in order to
--   update the current visible tooltip, or to show/hide the current
--   tooltip. This function is useful to call when, for example, the state
--   of the widget changed by a key press.
--   
--   <i>Since: 2.12</i>
tooltipTriggerTooltipQuery :: (HasCallStack, MonadIO m, IsDisplay a) => a -> m ()

-- | Invokes <i><tt>callback</tt></i> on each direct child of
--   <i><tt>container</tt></i>, including children that are considered
--   “internal” (implementation details of the container). “Internal”
--   children generally weren’t added by the user of the container, but
--   were added by the container implementation itself.
--   
--   Most applications should use <a>containerForeach</a>, rather than
--   <a>containerForall</a>.
containerForall :: (HasCallStack, MonadIO m, IsContainer a) => a -> Callback -> m ()

-- | Sets the number of decimal places that are displayed in the value.
--   Also causes the value of the adjustment to be rounded to this number
--   of digits, so the retrieved value matches the displayed one, if
--   <a>Scale:drawValue</a> is <a>True</a> when the value changes. If you
--   want to enforce rounding the value when <a>Scale:drawValue</a> is
--   <a>False</a>, you can set <a>Range:roundDigits</a> instead.
--   
--   Note that rounding to a small number of digits can interfere with the
--   smooth autoscrolling that is built into <a>Scale</a>. As an
--   alternative, you can use the <a>Scale::formatValue</a> signal to
--   format the displayed value yourself.
scaleSetDigits :: (HasCallStack, MonadIO m, IsScale a) => a -> Int32 -> m ()

-- | Invokes the virtual render function of the <a>CellRenderer</a>. The
--   three passed-in rectangles are areas in <i><tt>cr</tt></i>. Most
--   renderers will draw within <i><tt>cellArea</tt></i>; the xalign,
--   yalign, xpad, and ypad fields of the <a>CellRenderer</a> should be
--   honored with respect to <i><tt>cellArea</tt></i>.
--   <i><tt>backgroundArea</tt></i> includes the blank space around the
--   cell, and also the area containing the tree expander; so the
--   <i><tt>backgroundArea</tt></i> rectangles for all cells tile to cover
--   the entire <i><tt>window</tt></i>.
cellRendererRender :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> Context -> b -> Rectangle -> Rectangle -> [CellRendererState] -> m ()

-- | Frees <i><tt>path</tt></i>. If <i><tt>path</tt></i> is <a>Nothing</a>,
--   it simply returns.
treePathFree :: (HasCallStack, MonadIO m) => Maybe TreePath -> m ()

-- | Packs the <i><tt>cell</tt></i> into the beginning of the column. If
--   <i><tt>expand</tt></i> is <a>False</a>, then the <i><tt>cell</tt></i>
--   is allocated no more space than it needs. Any unused space is divided
--   evenly between cells for which <i><tt>expand</tt></i> is <a>True</a>.
treeViewColumnPackStart :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> Bool -> m ()

-- | Sets the area of the widget, where the contents of this tooltip apply,
--   to be <i><tt>rect</tt></i> (in widget coordinates). This is especially
--   useful for properly setting tooltips on <a>TreeView</a> rows and
--   cells, <tt><i>GtkIconViews</i></tt>, etc.
--   
--   For setting tooltips on <a>TreeView</a>, please refer to the
--   convenience functions for this: <a>treeViewSetTooltipRow</a> and
--   <a>treeViewSetTooltipCell</a>.
--   
--   <i>Since: 2.12</i>
tooltipSetTipArea :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Rectangle -> m ()

-- | Creates a row reference based on <i><tt>path</tt></i>.
--   
--   This reference will keep pointing to the node pointed to by
--   <i><tt>path</tt></i>, so long as it exists. Any changes that occur on
--   <i><tt>model</tt></i> are propagated, and the path is updated
--   appropriately. If <i><tt>path</tt></i> isn’t a valid path in
--   <i><tt>model</tt></i>, then <a>Nothing</a> is returned.
treeRowReferenceNew :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> m TreeRowReference

-- | Lets the tree ref the node.
--   
--   This is an optional method for models to implement. To be more
--   specific, models may ignore this call as it exists primarily for
--   performance reasons.
--   
--   This function is primarily meant as a way for views to let caching
--   models know when nodes are being displayed (and hence, whether or not
--   to cache that node). Being displayed means a node is in an expanded
--   branch, regardless of whether the node is currently visible in the
--   viewport. For example, a file-system based model would not want to
--   keep the entire file-hierarchy in memory, just the sections that are
--   currently being displayed by every current view.
--   
--   A model should be expected to be able to get an iter independent of
--   its reffed state.
treeModelRefNode :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m ()

-- | Sets the tip area of <i><tt>tooltip</tt></i> to be the area covered by
--   the row at <i><tt>path</tt></i>. See also
--   <a>treeViewSetTooltipColumn</a> for a simpler alternative. See also
--   <a>tooltipSetTipArea</a>.
--   
--   <i>Since: 2.12</i>
treeViewSetTooltipRow :: (HasCallStack, MonadIO m, IsTreeView a, IsTooltip b) => a -> b -> TreePath -> m ()

-- | Sets the tip area of <i><tt>tooltip</tt></i> to the area
--   <i><tt>path</tt></i>, <i><tt>column</tt></i> and <i><tt>cell</tt></i>
--   have in common. For example if <i><tt>path</tt></i> is <a>Nothing</a>
--   and <i><tt>column</tt></i> is set, the tip area will be set to the
--   full area covered by <i><tt>column</tt></i>. See also
--   <a>tooltipSetTipArea</a>.
--   
--   Note that if <i><tt>path</tt></i> is not specified and
--   <i><tt>cell</tt></i> is set and part of a column containing the
--   expander, the tooltip might not show and hide at the correct position.
--   In such cases <i><tt>path</tt></i> must be set to the current node
--   under the mouse cursor for this function to operate correctly.
--   
--   See also <a>treeViewSetTooltipColumn</a> for a simpler alternative.
--   
--   <i>Since: 2.12</i>
treeViewSetTooltipCell :: (HasCallStack, MonadIO m, IsTreeView a, IsTooltip b, IsTreeViewColumn c, IsCellRenderer d) => a -> b -> Maybe TreePath -> Maybe c -> Maybe d -> m ()

-- | Sets the relief style of the edges of the given <a>Button</a> widget.
--   Two styles exist, <a>ReliefStyleNormal</a> and <a>ReliefStyleNone</a>.
--   The default style is, as one can guess, <a>ReliefStyleNormal</a>. The
--   deprecated value <a>ReliefStyleHalf</a> behaves the same as
--   <a>ReliefStyleNormal</a>.
buttonSetRelief :: (HasCallStack, MonadIO m, IsButton a) => a -> ReliefStyle -> m ()

-- | Sets the <a>MenuItem</a> used in the toolbar overflow menu. The
--   <i><tt>menuItemId</tt></i> is used to identify the caller of this
--   function and should also be used with <a>toolItemGetProxyMenuItem</a>.
--   
--   See also <a>ToolItem::createMenuProxy</a>.
--   
--   <i>Since: 2.4</i>
toolItemSetProxyMenuItem :: (HasCallStack, MonadIO m, IsToolItem a, IsWidget b) => a -> Text -> Maybe b -> m ()

-- | Sets a widget as a potential drop destination, and adds default
--   behaviors.
--   
--   The default behaviors listed in <i><tt>flags</tt></i> have an effect
--   similar to installing default handlers for the widget’s drag-and-drop
--   signals (<a>Widget::dragMotion</a>, <a>Widget::dragDrop</a>, ...).
--   They all exist for convenience. When passing
--   <tt><i>GTK_DEST_DEFAULT_ALL</i></tt> for instance it is sufficient to
--   connect to the widget’s <a>Widget::dragDataReceived</a> signal to get
--   primitive, but consistent drag-and-drop support.
--   
--   Things become more complicated when you try to preview the dragged
--   data, as described in the documentation for <a>Widget::dragMotion</a>.
--   The default behaviors described by <i><tt>flags</tt></i> make some
--   assumptions, that can conflict with your own signal handlers. For
--   instance <tt><i>GTK_DEST_DEFAULT_DROP</i></tt> causes invokations of
--   <a>dragStatus</a> in the context of <a>Widget::dragMotion</a>, and
--   invokations of <a>dragFinish</a> in <a>Widget::dragDataReceived</a>.
--   Especially the later is dramatic, when your own
--   <a>Widget::dragMotion</a> handler calls <a>widgetDragGetData</a> to
--   inspect the dragged data.
--   
--   There’s no way to set a default action here, you can use the
--   <a>Widget::dragMotion</a> callback for that. Here’s an example which
--   selects the action to use depending on whether the control key is
--   pressed or not:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   static void
--   drag_motion (GtkWidget *widget,
--                GdkDragContext *context,
--                gint x,
--                gint y,
--                guint time)
--   {
--     GdkModifierType mask;
--   
--     gdk_window_get_pointer (gtk_widget_get_window (widget),
--                             NULL, NULL, &amp;mask);
--     if (mask &amp; GDK_CONTROL_MASK)
--       gdk_drag_status (context, GDK_ACTION_COPY, time);
--     else
--       gdk_drag_status (context, GDK_ACTION_MOVE, time);
--   }
--   </pre>
widgetDragDestSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> [DestDefaults] -> Maybe [TargetEntry] -> [DragAction] -> m ()

-- | Sets up a widget so that GTK+ will start a drag operation when the
--   user clicks and drags on the widget. The widget must have a window.
widgetDragSourceSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> [ModifierType] -> Maybe [TargetEntry] -> [DragAction] -> m ()

-- | Retrieves the current orientation for the tool shell. Tool items must
--   not call this function directly, but rely on
--   <a>toolItemGetOrientation</a> instead.
--   
--   <i>Since: 2.14</i>
toolShellGetOrientation :: (HasCallStack, MonadIO m, IsToolShell a) => a -> m Orientation

-- | Retrieves whether the tool shell has text, icons, or both. Tool items
--   must not call this function directly, but rely on
--   <a>toolItemGetToolbarStyle</a> instead.
--   
--   <i>Since: 2.14</i>
toolShellGetStyle :: (HasCallStack, MonadIO m, IsToolShell a) => a -> m ToolbarStyle

-- | Retrieves the icon size for the tool shell. Tool items must not call
--   this function directly, but rely on <a>toolItemGetIconSize</a>
--   instead.
--   
--   <i>Since: 2.14</i>
toolShellGetIconSize :: (HasCallStack, MonadIO m, IsToolShell a) => a -> m Int32

-- | Returns the relief style of buttons on <i><tt>shell</tt></i>. Tool
--   items must not call this function directly, but rely on
--   <a>toolItemGetReliefStyle</a> instead.
--   
--   <i>Since: 2.14</i>
toolShellGetReliefStyle :: (HasCallStack, MonadIO m, IsToolShell a) => a -> m ReliefStyle

-- | Sets <i><tt>markup</tt></i> as the contents of the tooltip, which is
--   marked up with the [Pango text markup language][PangoMarkupFormat].
--   
--   This function will take care of setting <a>Widget:hasTooltip</a> to
--   <a>True</a> and of the default handler for the
--   <a>Widget::queryTooltip</a> signal.
--   
--   See also the <a>Widget:tooltipMarkup</a> property and
--   <a>tooltipSetMarkup</a>.
--   
--   <i>Since: 2.12</i>
widgetSetTooltipMarkup :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Text -> m ()

-- | Sets <i><tt>text</tt></i> as the contents of the tooltip. This
--   function will take care of setting <a>Widget:hasTooltip</a> to
--   <a>True</a> and of the default handler for the
--   <a>Widget::queryTooltip</a> signal.
--   
--   See also the <a>Widget:tooltipText</a> property and
--   <a>tooltipSetText</a>.
--   
--   <i>Since: 2.12</i>
widgetSetTooltipText :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Text -> m ()

-- | Creates a new <a>Button</a> widget. To add a child widget to the
--   button, use <a>containerAdd</a>.
buttonNew :: (HasCallStack, MonadIO m) => m Button

-- | Creates a new <a>Label</a>, containing the text in
--   <i><tt>str</tt></i>.
--   
--   If characters in <i><tt>str</tt></i> are preceded by an underscore,
--   they are underlined. If you need a literal underscore character in a
--   label, use '__' (two underscores). The first underlined character
--   represents a keyboard accelerator called a mnemonic. The mnemonic key
--   can be used to activate another widget, chosen automatically, or
--   explicitly using <a>labelSetMnemonicWidget</a>.
--   
--   If <a>labelSetMnemonicWidget</a> is not called, then the first
--   activatable ancestor of the <a>Label</a> will be chosen as the
--   mnemonic widget. For instance, if the label is inside a button or menu
--   item, the button or menu item will automatically become the mnemonic
--   widget and be activated by the mnemonic.
labelNewWithMnemonic :: (HasCallStack, MonadIO m) => Maybe Text -> m Label

-- | Adds an action object to the action group and sets up the accelerator.
--   
--   If <i><tt>accelerator</tt></i> is <a>Nothing</a>, attempts to use the
--   accelerator associated with the stock_id of the action.
--   
--   Accel paths are set to
--   <tt>&lt;Actions&gt;/group-name/action-name</tt>.
--   
--   <i>Since: 2.4</i>
actionGroupAddActionWithAccel :: (HasCallStack, MonadIO m, IsActionGroup a, IsAction b) => a -> b -> Maybe Text -> m ()

-- | Pushes an animatable region, so all further gtk_render_*() calls
--   between this call and the following
--   <a>styleContextPopAnimatableRegion</a> will potentially show
--   transition animations for this region if
--   <a>styleContextNotifyStateChange</a> is called for a given state, and
--   the current theme/style defines transition animations for state
--   changes.
--   
--   The <i><tt>regionId</tt></i> used must be unique in
--   <i><tt>context</tt></i> so the themes can uniquely identify rendered
--   elements subject to a state transition.
--   
--   <i>Since: 3.0</i>
styleContextPushAnimatableRegion :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Ptr () -> m ()

-- | Computes the effect of any tags applied to this spot in the text. The
--   <i><tt>values</tt></i> parameter should be initialized to the default
--   settings you wish to use if no tags are in effect. You’d typically
--   obtain the defaults from <a>textViewGetDefaultAttributes</a>.
--   
--   <a>textIterGetAttributes</a> will modify <i><tt>values</tt></i>,
--   applying the effects of any tags present at <i><tt>iter</tt></i>. If
--   any tags affected <i><tt>values</tt></i>, the function returns
--   <a>True</a>.
textIterGetAttributes :: (HasCallStack, MonadIO m) => TextIter -> m (Bool, TextAttributes)

-- | Decrements the reference count on <i><tt>values</tt></i>, freeing the
--   structure if the reference count reaches 0.
textAttributesUnref :: (HasCallStack, MonadIO m) => TextAttributes -> m ()

-- | Allow an input method to internally handle key press and release
--   events. If this function returns <a>True</a>, then no further
--   processing should be done for this key event.
iMContextFilterKeypress :: (HasCallStack, MonadIO m, IsIMContext a) => a -> EventKey -> m Bool

-- | Returns the size of the table (number of tags)
textTagTableGetSize :: (HasCallStack, MonadIO m, IsTextTagTable a) => a -> m Int32

-- | Adds the mark at position <i><tt>where</tt></i>. The mark must not be
--   added to another buffer, and if its name is not <a>Nothing</a> then
--   there must not be another mark in the buffer with the same name.
--   
--   Emits the <a>TextBuffer::markSet</a> signal as notification of the
--   mark's initial placement.
--   
--   <i>Since: 2.12</i>
textBufferAddMark :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextMark b) => a -> b -> TextIter -> m ()

-- | Returns the mark named <i><tt>name</tt></i> in buffer
--   <i><tt>buffer</tt></i>, or <a>Nothing</a> if no such mark exists in
--   the buffer.
textBufferGetMark :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> m (Maybe TextMark)

-- | Deletes <i><tt>mark</tt></i>, so that it’s no longer located anywhere
--   in the buffer. Removes the reference the buffer holds to the mark, so
--   if you haven’t called <a>objectRef</a> on the mark, it will be freed.
--   Even if the mark isn’t freed, most operations on <i><tt>mark</tt></i>
--   become invalid, until it gets added to a buffer again with
--   <a>textBufferAddMark</a>. Use <a>textMarkGetDeleted</a> to find out if
--   a mark has been removed from its buffer. The
--   <a>TextBuffer::markDeleted</a> signal will be emitted as notification
--   after the mark is deleted.
textBufferDeleteMark :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextMark b) => a -> b -> m ()

-- | Inserts a child widget anchor into the text buffer at
--   <i><tt>iter</tt></i>. The anchor will be counted as one character in
--   character counts, and when obtaining the buffer contents as a string,
--   will be represented by the Unicode “object replacement character”
--   0xFFFC. Note that the “slice” variants for obtaining portions of the
--   buffer as a string include this character for child anchors, but the
--   “text” variants do not. E.g. see <a>textBufferGetSlice</a> and
--   <a>textBufferGetText</a>. Consider <a>textBufferCreateChildAnchor</a>
--   as a more convenient alternative to this function. The buffer will add
--   a reference to the anchor, so you can unref it after insertion.
textBufferInsertChildAnchor :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextChildAnchor b) => a -> TextIter -> b -> m ()

-- | This is a convenience function which simply creates a child anchor
--   with <a>textChildAnchorNew</a> and inserts it into the buffer with
--   <a>textBufferInsertChildAnchor</a>. The new anchor is owned by the
--   buffer; no reference count is returned to the caller of
--   <a>textBufferCreateChildAnchor</a>.
textBufferCreateChildAnchor :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> m TextChildAnchor

-- | Look up a named tag.
textTagTableLookup :: (HasCallStack, MonadIO m, IsTextTagTable a) => a -> Text -> m (Maybe TextTag)

-- | Creates a new <a>TextChildAnchor</a>. Usually you would then insert it
--   into a <a>TextBuffer</a> with <a>textBufferInsertChildAnchor</a>. To
--   perform the creation and insertion in one step, use the convenience
--   function <a>textBufferCreateChildAnchor</a>.
textChildAnchorNew :: (HasCallStack, MonadIO m) => m TextChildAnchor

-- | Returns <a>True</a> if the mark has been removed from its buffer with
--   <a>textBufferDeleteMark</a>. See <a>textBufferAddMark</a> for a way to
--   add it to a buffer again.
textMarkGetDeleted :: (HasCallStack, MonadIO m, IsTextMark a) => a -> m Bool

-- | Appends the rich text targets registered with
--   <a>textBufferRegisterSerializeFormat</a> or
--   <a>textBufferRegisterDeserializeFormat</a> to the target list. All
--   targets are added with the same <i><tt>info</tt></i>.
--   
--   <i>Since: 2.10</i>
targetListAddRichTextTargets :: (HasCallStack, MonadIO m, IsTextBuffer a) => TargetList -> Word32 -> Bool -> a -> m ()

-- | The Unicode character at this iterator is returned. (Equivalent to
--   operator* on a C++ iterator.) If the element at this iterator is a
--   non-character element, such as an image embedded in the buffer, the
--   Unicode “unknown” character 0xFFFC is returned. If invoked on the end
--   iterator, zero is returned; zero is not a valid Unicode character. So
--   you can write a loop which ends when <a>textIterGetChar</a> returns 0.
textIterGetChar :: (HasCallStack, MonadIO m) => TextIter -> m Char

-- | Returns the default editability of the <a>TextView</a>. Tags in the
--   buffer may override this setting for some ranges of text.
textViewGetEditable :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Bool

-- | Returns the style context associated to <i><tt>widget</tt></i>. The
--   returned object is guaranteed to be the same for the lifetime of
--   <i><tt>widget</tt></i>.
widgetGetStyleContext :: (HasCallStack, MonadIO m, IsWidget a) => a -> m StyleContext

-- | Renders the background of an element.
--   
--   Typical background rendering, showing the effect of
--   <tt>background-image</tt>, <tt>border-width</tt> and
--   <tt>border-radius</tt>:
--   
--   
--   <i>Since: 3.0</i>
renderBackground :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Returns the widget state as a flag set. It is worth mentioning that
--   the effective <a>StateFlagsInsensitive</a> state will be returned,
--   that is, also based on parent insensitivity, even if
--   <i><tt>widget</tt></i> itself is sensitive.
--   
--   Also note that if you are looking for a way to obtain the
--   <a>StateFlags</a> to pass to a <a>StyleContext</a> method, you should
--   look at <a>styleContextGetState</a>.
--   
--   <i>Since: 3.0</i>
widgetGetStateFlags :: (HasCallStack, MonadIO m, IsWidget a) => a -> m [StateFlags]

-- | Adds an icon factory to the list of icon factories searched by
--   <a>styleLookupIconSet</a>. This means that, for example,
--   <a>imageNewFromStock</a> will be able to find icons in
--   <i><tt>factory</tt></i>. There will normally be an icon factory added
--   for each library or application that comes with icons. The default
--   icon factories can be overridden by themes.
iconFactoryAddDefault :: (HasCallStack, MonadIO m, IsIconFactory a) => a -> m ()

-- | Adds the given <i><tt>iconSet</tt></i> to the icon factory, under the
--   name <i><tt>stockId</tt></i>. <i><tt>stockId</tt></i> should be
--   namespaced for your application, e.g. “myapp-whatever-icon”. Normally
--   applications create a <a>IconFactory</a>, then add it to the list of
--   default factories with <a>iconFactoryAddDefault</a>. Then they pass
--   the <i><tt>stockId</tt></i> to widgets such as <a>Image</a> to display
--   the icon. Themes can provide an icon with the same name (such as
--   "myapp-whatever-icon") to override your application’s default icons.
--   If an icon already existed in <i><tt>factory</tt></i> for
--   <i><tt>stockId</tt></i>, it is unreferenced and replaced with the new
--   <i><tt>iconSet</tt></i>.
iconFactoryAdd :: (HasCallStack, MonadIO m, IsIconFactory a) => a -> Text -> IconSet -> m ()

-- | Retrieves the contents of the entry widget. See also
--   <a>editableGetChars</a>.
--   
--   This is equivalent to getting <i><tt>entry</tt></i>'s
--   <a>EntryBuffer</a> and calling <a>entryBufferGetText</a> on it.
entryGetText :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Text

-- | Gets the window ID of a <a>Plug</a> widget, which can then be used to
--   embed this window inside another window, for instance with
--   <a>socketAddId</a>.
plugGetId :: (HasCallStack, MonadIO m, IsPlug a) => a -> m CULong

-- | Creates a new plug widget inside the <a>Socket</a> identified by
--   <i><tt>socketId</tt></i>. If <i><tt>socketId</tt></i> is 0, the plug
--   is left “unplugged” and can later be plugged into a <a>Socket</a> by
--   <a>socketAddId</a>.
plugNew :: (HasCallStack, MonadIO m) => CULong -> m Plug

-- | Sets whether <i><tt>toolItem</tt></i> is allocated extra space when
--   there is more room on the toolbar then needed for the items. The
--   effect is that the item gets bigger when the toolbar gets bigger and
--   smaller when the toolbar gets smaller.
--   
--   <i>Since: 2.4</i>
toolItemSetExpand :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Bool -> m ()

-- | This function should be called when the top-level window which
--   contains the search bar received a key event.
--   
--   If the key event is handled by the search bar, the bar will be shown,
--   the entry populated with the entered text and <a>EVENT_STOP</a> will
--   be returned. The caller should ensure that events are not propagated
--   further.
--   
--   If no entry has been connected to the search bar, using
--   <a>searchBarConnectEntry</a>, this function will return immediately
--   with a warning.
--   
--   <h2>Showing the search bar on key presses</h2>
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   static gboolean
--   on_key_press_event (GtkWidget *widget,
--                       GdkEvent  *event,
--                       gpointer   user_data)
--   {
--     GtkSearchBar *bar = GTK_SEARCH_BAR (user_data);
--     return gtk_search_bar_handle_event (bar, event);
--   }
--   
--   static void
--   create_toplevel (void)
--   {
--     GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
--     GtkWindow *search_bar = gtk_search_bar_new ();
--   
--    // Add more widgets to the window...
--   
--     g_signal_connect (window,
--                      "key-press-event",
--                       G_CALLBACK (on_key_press_event),
--                       search_bar);
--   }
--   </pre>
--   
--   <i>Since: 3.10</i>
searchBarHandleEvent :: (HasCallStack, MonadIO m, IsSearchBar a) => a -> Event -> m Bool

-- | Adds <i><tt>widget</tt></i> to <i><tt>container</tt></i>. Typically
--   used for simple containers such as <a>Window</a>, <a>Frame</a>, or
--   <a>Button</a>; for more complicated layout containers such as
--   <a>Box</a> or <a>Grid</a>, this function will pick default packing
--   parameters that may not be correct. So consider functions such as
--   <a>boxPackStart</a> and <a>gridAttach</a> as an alternative to
--   <a>containerAdd</a> in those cases. A widget may be added to only one
--   container at a time; you can’t place the same widget inside two
--   different containers.
--   
--   Note that some containers, such as <a>ScrolledWindow</a> or
--   <a>ListBox</a>, may add intermediate children between the added widget
--   and the container.
containerAdd :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> b -> m ()

-- | Get the <a>Adjustment</a> which is the “model” object for
--   <a>Range</a>. See <a>rangeSetAdjustment</a> for details. The return
--   value does not have a reference added, so should not be unreferenced.
rangeGetAdjustment :: (HasCallStack, MonadIO m, IsRange a) => a -> m Adjustment

-- | Sets the adjustment to be used as the “model” object for this range
--   widget. The adjustment indicates the current range value, the minimum
--   and maximum range values, the step/page increments used for
--   keybindings and scrolling, and the page size. The page size is
--   normally 0 for <a>Scale</a> and nonzero for <a>Scrollbar</a>, and
--   indicates the size of the visible area of the widget being scrolled.
--   The page size affects the size of the scrollbar slider.
rangeSetAdjustment :: (HasCallStack, MonadIO m, IsRange a, IsAdjustment b) => a -> b -> m ()

-- | Sets whether a number should be added to the items of
--   <i><tt>menu</tt></i>. The numbers are shown to provide a unique
--   character for a mnemonic to be used inside ten menu item’s label. Only
--   the first the items get a number to avoid clashes.
--   
--   <i>Since: 2.10</i>
recentChooserMenuSetShowNumbers :: (HasCallStack, MonadIO m, IsRecentChooserMenu a) => a -> Bool -> m ()

-- | Gets the reading direction for a particular widget. See
--   <a>widgetSetDirection</a>.
widgetGetDirection :: (HasCallStack, MonadIO m, IsWidget a) => a -> m TextDirection

-- | Returns whether the given page is included in the set of pages that
--   have been selected for printing.
--   
--   <i>Since: 2.10</i>
printOperationPreviewIsSelected :: (HasCallStack, MonadIO m, IsPrintOperationPreview a) => a -> Int32 -> m Bool

-- | Renders a page to the preview, using the print context that was passed
--   to the <a>PrintOperation::preview</a> handler together with
--   <i><tt>preview</tt></i>.
--   
--   A custom iprint preview should use this function in its <a>expose</a>
--   handler to render the currently selected page.
--   
--   Note that this function requires a suitable cairo context to be
--   associated with the print context.
--   
--   <i>Since: 2.10</i>
printOperationPreviewRenderPage :: (HasCallStack, MonadIO m, IsPrintOperationPreview a) => a -> Int32 -> m ()

-- | Ends a preview.
--   
--   This function must be called to finish a custom print preview.
--   
--   <i>Since: 2.10</i>
printOperationPreviewEndPreview :: (HasCallStack, MonadIO m, IsPrintOperationPreview a) => a -> m ()

-- | Obtains the cairo context that is associated with the
--   <a>PrintContext</a>.
--   
--   <i>Since: 2.10</i>
printContextGetCairoContext :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Context

-- | Inserts <i><tt>group</tt></i> into <i><tt>widget</tt></i>. Children of
--   <i><tt>widget</tt></i> that implement <a>Actionable</a> can then be
--   associated with actions in <i><tt>group</tt></i> by setting their
--   “action-name” to <i><tt>prefix</tt></i>.<tt>action-name</tt>.
--   
--   If <i><tt>group</tt></i> is <a>Nothing</a>, a previously inserted
--   group for <i><tt>name</tt></i> is removed from <i><tt>widget</tt></i>.
--   
--   <i>Since: 3.6</i>
widgetInsertActionGroup :: (HasCallStack, MonadIO m, IsWidget a, IsActionGroup b) => a -> Text -> Maybe b -> m ()

-- | Reverses the effects of <a>widgetShow</a>, causing the widget to be
--   hidden (invisible to the user).
widgetHide :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | The default widget is the widget that’s activated when the user
--   presses Enter in a dialog (for example). This function sets or unsets
--   the default widget for a <a>Window</a>. When setting (rather than
--   unsetting) the default widget it’s generally easier to call
--   <a>widgetGrabDefault</a> on the widget. Before making a widget the
--   default widget, you must call <a>widgetSetCanDefault</a> on the widget
--   you’d like to make the default.
windowSetDefault :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> m ()

-- | Adds an XEMBED client, such as a <a>Plug</a>, to the <a>Socket</a>.
--   The client may be in the same process or in a different process.
--   
--   To embed a <a>Plug</a> in a <a>Socket</a>, you can either create the
--   <a>Plug</a> with <tt>gtk_plug_new (0)</tt>, call <a>plugGetId</a> to
--   get the window ID of the plug, and then pass that to the
--   <a>socketAddId</a>, or you can call <a>socketGetId</a> to get the
--   window ID for the socket, and call <a>plugNew</a> passing in that ID.
--   
--   The <a>Socket</a> must have already be added into a toplevel window
--   before you can make this call.
socketAddId :: (HasCallStack, MonadIO m, IsSocket a) => a -> CULong -> m ()

-- | Returns the content area of <i><tt>dialog</tt></i>.
--   
--   <i>Since: 2.14</i>
dialogGetContentArea :: (HasCallStack, MonadIO m, IsDialog a) => a -> m Box

-- | Sets the text to be displayed as tooltip on the item. See
--   <a>widgetSetTooltipText</a>.
--   
--   <i>Since: 2.12</i>
toolItemSetTooltipText :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Text -> m ()

-- | Creates a <a>Menu</a> and populates it with menu items and submenus
--   according to <i><tt>model</tt></i>.
--   
--   The created menu items are connected to actions found in the
--   <a>ApplicationWindow</a> to which the menu belongs - typically by
--   means of being attached to a widget (see <a>menuAttachToWidget</a>)
--   that is contained within the <tt><i>GtkApplicationWindows</i></tt>
--   widget hierarchy.
--   
--   Actions can also be added using <a>widgetInsertActionGroup</a> on the
--   menu's attach widget or on any of its parent widgets.
--   
--   <i>Since: 3.4</i>
menuNewFromModel :: (HasCallStack, MonadIO m, IsMenuModel a) => a -> m Menu

-- | Creates a new <a>MenuBar</a> and populates it with menu items and
--   submenus according to <i><tt>model</tt></i>.
--   
--   The created menu items are connected to actions found in the
--   <a>ApplicationWindow</a> to which the menu bar belongs - typically by
--   means of being contained within the
--   <tt><i>GtkApplicationWindows</i></tt> widget hierarchy.
--   
--   <i>Since: 3.4</i>
menuBarNewFromModel :: (HasCallStack, MonadIO m, IsMenuModel a) => a -> m MenuBar

-- | Sets or unsets the application menu for <i><tt>application</tt></i>.
--   
--   This can only be done in the primary instance of the application,
--   after it has been registered. <a>Application::startup</a> is a good
--   place to call this.
--   
--   The application menu is a single menu containing items that typically
--   impact the application as a whole, rather than acting on a specific
--   window or document. For example, you would expect to see “Preferences”
--   or “Quit” in an application menu, but not “Save” or “Print”.
--   
--   If supported, the application menu will be rendered by the desktop
--   environment.
--   
--   Use the base <a>ActionMap</a> interface to add actions, to respond to
--   the user selecting these menu items.
--   
--   <i>Since: 3.4</i>
applicationSetAppMenu :: (HasCallStack, MonadIO m, IsApplication a, IsMenuModel b) => a -> Maybe b -> m ()

-- | Sets or unsets the menubar for windows of <i><tt>application</tt></i>.
--   
--   This is a menubar in the traditional sense.
--   
--   This can only be done in the primary instance of the application,
--   after it has been registered. <a>Application::startup</a> is a good
--   place to call this.
--   
--   Depending on the desktop environment, this may appear at the top of
--   each window, or at the top of the screen. In some environments, if
--   both the application menu and the menubar are set, the application
--   menu will be presented as if it were the first item of the menubar.
--   Other environments treat the two as completely separate — for example,
--   the application menu may be rendered by the desktop shell while the
--   menubar (if set) remains in each individual window.
--   
--   Use the base <a>ActionMap</a> interface to add actions, to respond to
--   the user selecting these menu items.
--   
--   <i>Since: 3.4</i>
applicationSetMenubar :: (HasCallStack, MonadIO m, IsApplication a, IsMenuModel b) => a -> Maybe b -> m ()

-- | Sets an accelerator path for this menu from which accelerator paths
--   for its immediate children, its menu items, can be constructed. The
--   main purpose of this function is to spare the programmer the
--   inconvenience of having to call <a>menuItemSetAccelPath</a> on each
--   menu item that should support runtime user changable accelerators.
--   Instead, by just calling <a>menuSetAccelPath</a> on their parent, each
--   menu item of this menu, that contains a label describing its purpose,
--   automatically gets an accel path assigned.
--   
--   For example, a menu containing menu items “New” and “Exit”, will,
--   after <tt>gtk_menu_set_accel_path (menu,
--   "&lt;Gnumeric-Sheet&gt;/File");</tt> has been called, assign its items
--   the accel paths: <tt>"&lt;Gnumeric-Sheet&gt;/File/New"</tt> and
--   <tt>"&lt;Gnumeric-Sheet&gt;/File/Exit"</tt>.
--   
--   Assigning accel paths to menu items then enables the user to change
--   their accelerators at runtime. More details about accelerator paths
--   and their default setups can be found at <a>accelMapAddEntry</a>.
--   
--   Note that <i><tt>accelPath</tt></i> string will be stored in a
--   <tt><i>GQuark</i></tt>. Therefore, if you pass a static string, you
--   can save some memory by interning it first with
--   <a>internStaticString</a>.
menuSetAccelPath :: (HasCallStack, MonadIO m, IsMenu a) => a -> Maybe Text -> m ()

-- | Given an accelerator group, <i><tt>accelGroup</tt></i>, and an
--   accelerator path, <i><tt>accelPath</tt></i>, sets up an accelerator in
--   <i><tt>accelGroup</tt></i> so whenever the key binding that is defined
--   for <i><tt>accelPath</tt></i> is pressed, <i><tt>widget</tt></i> will
--   be activated. This removes any accelerators (for any accelerator
--   group) installed by previous calls to <a>widgetSetAccelPath</a>.
--   Associating accelerators with paths allows them to be modified by the
--   user and the modifications to be saved for future use. (See
--   <a>accelMapSave</a>.)
--   
--   This function is a low level function that would most likely be used
--   by a menu creation system like <a>UIManager</a>. If you use
--   <a>UIManager</a>, setting up accelerator paths will be done
--   automatically.
--   
--   Even when you you aren’t using <a>UIManager</a>, if you only want to
--   set up accelerators on menu items <a>menuItemSetAccelPath</a> provides
--   a somewhat more convenient interface.
--   
--   Note that <i><tt>accelPath</tt></i> string will be stored in a
--   <tt><i>GQuark</i></tt>. Therefore, if you pass a static string, you
--   can save some memory by interning it first with
--   <a>internStaticString</a>.
widgetSetAccelPath :: (HasCallStack, MonadIO m, IsWidget a, IsAccelGroup b) => a -> Maybe Text -> Maybe b -> m ()

-- | Set the <a>AccelGroup</a> which holds global accelerators for the
--   menu. This accelerator group needs to also be added to all windows
--   that this menu is being used in with <a>windowAddAccelGroup</a>, in
--   order for those windows to support all the accelerators contained in
--   this group.
menuSetAccelGroup :: (HasCallStack, MonadIO m, IsMenu a, IsAccelGroup b) => a -> Maybe b -> m ()

-- | Creates a <a>Popover</a> and populates it according to
--   <i><tt>model</tt></i>. The popover is pointed to the
--   <i><tt>relativeTo</tt></i> widget.
--   
--   The created buttons are connected to actions found in the
--   <a>ApplicationWindow</a> to which the popover belongs - typically by
--   means of being attached to a widget that is contained within the
--   <tt><i>GtkApplicationWindows</i></tt> widget hierarchy.
--   
--   Actions can also be added using <a>widgetInsertActionGroup</a> on the
--   menus attach widget or on any of its parent widgets.
--   
--   <i>Since: 3.12</i>
popoverNewFromModel :: (HasCallStack, MonadIO m, IsWidget a, IsMenuModel b) => Maybe a -> b -> m Popover

-- | If there is a current event and it has a timestamp, return that
--   timestamp, otherwise return <a>CURRENT_TIME</a>.
getCurrentEventTime :: (HasCallStack, MonadIO m) => m Word32

-- | Update the sorting for all rows. Call this when result of the sort
--   function on the <i><tt>box</tt></i> is changed due to an external
--   factor.
--   
--   <i>Since: 3.10</i>
listBoxInvalidateSort :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Highlights a widget as a currently hovered drop target. To end the
--   highlight, call <a>widgetDragUnhighlight</a>. GTK+ calls this
--   automatically if <a>DestDefaultsHighlight</a> is set.
widgetDragHighlight :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Marks <i><tt>row</tt></i> as changed, causing any state that depends
--   on this to be updated. This affects sorting, filtering and headers.
--   
--   Note that calls to this method must be in sync with the data used for
--   the row functions. For instance, if the list is mirroring some
--   external data set, and *two* rows changed in the external data set
--   then when you call <a>listBoxRowChanged</a> on the first row the sort
--   function must only read the new data for the first of the two changed
--   rows, otherwise the resorting of the rows will be wrong.
--   
--   This generally means that if you don’t fully control the data model
--   you have to duplicate the data that affects the listbox row functions
--   into the row widgets themselves. Another alternative is to call
--   <a>listBoxInvalidateSort</a> on any model change, but that is more
--   expensive.
--   
--   <i>Since: 3.10</i>
listBoxRowChanged :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m ()

-- | Returns the current header of the <i><tt>row</tt></i>. This can be
--   used in a <a>ListBoxUpdateHeaderFunc</a> to see if there is a header
--   set already, and if so to update the state of it.
--   
--   <i>Since: 3.10</i>
listBoxRowGetHeader :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m (Maybe Widget)

-- | This is a convenience function for launching the default application
--   to show the uri. The uri must be of a form understood by GIO (i.e. you
--   need to install gvfs to get support for uri schemes such as http:// or
--   ftp://, as only local files are handled by GIO itself). Typical
--   examples are
--   
--   <ul>
--   <li><pre>file:///home/gnome/pict.jpg</pre></li>
--   <li><pre>http://www.gnome.org</pre></li>
--   <li><pre>mailto:me@gnome.org</pre></li>
--   </ul>
--   
--   Ideally the timestamp is taken from the event triggering the
--   <a>showUri</a> call. If timestamp is not known you can take
--   <a>CURRENT_TIME</a>.
--   
--   This is the recommended call to be used as it passes information
--   necessary for sandbox helpers to parent their dialogs properly.
--   
--   <i>Since: 3.22</i>
showUriOnWindow :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> Text -> Word32 -> m ()

-- | Determines whether <i><tt>widget</tt></i> has a <a>Window</a> of its
--   own. See <a>widgetSetHasWindow</a>.
--   
--   <i>Since: 2.18</i>
widgetGetHasWindow :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Sets the horizontal alignment of <i><tt>widget</tt></i>. See the
--   <a>Widget:halign</a> property.
widgetSetHalign :: (HasCallStack, MonadIO m, IsWidget a) => a -> Align -> m ()

-- | Emits the <a>Dialog::response</a> signal with the given response ID.
--   Used to indicate that the user has responded to the dialog in some
--   way; typically either you or <a>dialogRun</a> will be monitoring the
--   <a>response</a> signal and take appropriate action.
dialogResponse :: (HasCallStack, MonadIO m, IsDialog a) => a -> Int32 -> m ()

-- | Fills <i><tt>item</tt></i> with the registered values for
--   <i><tt>stockId</tt></i>, returning <a>True</a> if
--   <i><tt>stockId</tt></i> was known.
stockLookup :: (HasCallStack, MonadIO m) => Text -> m (Bool, StockItem)

-- | Sets <i><tt>text</tt></i> on the <i><tt>menuItem</tt></i> label
--   
--   <i>Since: 2.16</i>
menuItemSetLabel :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> Text -> m ()

-- | Renders an icon previously looked up in an icon theme using
--   <a>iconThemeLookupIcon</a>; the size will be based on the size passed
--   to <a>iconThemeLookupIcon</a>. Note that the resulting pixbuf may not
--   be exactly this size; an icon theme may have icons that differ
--   slightly from their nominal sizes, and in addition GTK+ will avoid
--   scaling icons that it considers sufficiently close to the requested
--   size or for which the source image would have to be scaled up too far.
--   (This maintains sharpness.). This behaviour can be changed by passing
--   the <a>IconLookupFlagsForceSize</a> flag when obtaining the
--   <a>IconInfo</a>. If this flag has been specified, the pixbuf returned
--   by this function will be scaled to the exact size.
--   
--   <i>Since: 2.4</i>
iconInfoLoadIcon :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m Pixbuf

-- | Renders an icon previously looked up in an icon theme using
--   <a>iconThemeLookupIcon</a>; the size will be based on the size passed
--   to <a>iconThemeLookupIcon</a>. Note that the resulting surface may not
--   be exactly this size; an icon theme may have icons that differ
--   slightly from their nominal sizes, and in addition GTK+ will avoid
--   scaling icons that it considers sufficiently close to the requested
--   size or for which the source image would have to be scaled up too far.
--   (This maintains sharpness.). This behaviour can be changed by passing
--   the <a>IconLookupFlagsForceSize</a> flag when obtaining the
--   <a>IconInfo</a>. If this flag has been specified, the pixbuf returned
--   by this function will be scaled to the exact size.
--   
--   <i>Since: 3.10</i>
iconInfoLoadSurface :: (HasCallStack, MonadIO m, IsIconInfo a, IsWindow b) => a -> Maybe b -> m Surface

-- | Looks up <i><tt>stockId</tt></i> in the icon factories associated with
--   <i><tt>style</tt></i> and the default icon factory, returning an icon
--   set if found, otherwise <a>Nothing</a>.
styleLookupIconSet :: (HasCallStack, MonadIO m, IsStyle a) => a -> Text -> m IconSet

-- | Creates a <a>Image</a> displaying a stock icon. Sample stock icon
--   names are <a>STOCK_OPEN</a>, <a>STOCK_QUIT</a>. Sample stock sizes are
--   <tt><i>GTK_ICON_SIZE_MENU</i></tt>,
--   <tt><i>GTK_ICON_SIZE_SMALL_TOOLBAR</i></tt>. If the stock icon name
--   isn’t known, the image will be empty. You can register your own stock
--   icon names, see <a>iconFactoryAddDefault</a> and
--   <a>iconFactoryAdd</a>.
imageNewFromStock :: (HasCallStack, MonadIO m) => Text -> Int32 -> m Image

-- | Returns <a>True</a> if the gesture is currently active. A gesture is
--   active meanwhile there are touch sequences interacting with it.
--   
--   <i>Since: 3.14</i>
gestureIsActive :: (HasCallStack, MonadIO m, IsGesture a) => a -> m Bool

-- | Resets the <i><tt>controller</tt></i> to a clean state. Every
--   interaction the controller did through
--   <a>EventController</a>::<tt><i>handle-event</i></tt> will be dropped
--   at this point.
--   
--   <i>Since: 3.14</i>
eventControllerReset :: (HasCallStack, MonadIO m, IsEventController a) => a -> m ()

-- | Returns the <a>Widget</a> this controller relates to.
--   
--   <i>Since: 3.14</i>
eventControllerGetWidget :: (HasCallStack, MonadIO m, IsEventController a) => a -> m Widget

-- | Gets the currently-selected font name.
--   
--   Note that this can be a different string than what you set with
--   <a>fontChooserSetFont</a>, as the font chooser widget may normalize
--   font names and thus return a string with a different structure. For
--   example, “Helvetica Italic Bold 12” could be normalized to “Helvetica
--   Bold Italic 12”.
--   
--   Use <a>fontDescriptionEqual</a> if you want to compare two font
--   descriptions.
--   
--   <i>Since: 3.2</i>
fontChooserGetFont :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m (Maybe Text)

-- | Updates the sorting for all children.
--   
--   Call this when the result of the sort function on <i><tt>box</tt></i>
--   is changed due to an external factor.
--   
--   <i>Since: 3.12</i>
flowBoxInvalidateSort :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m ()

-- | Marks <i><tt>child</tt></i> as changed, causing any state that depends
--   on this to be updated. This affects sorting and filtering.
--   
--   Note that calls to this method must be in sync with the data used for
--   the sorting and filtering functions. For instance, if the list is
--   mirroring some external data set, and *two* children changed in the
--   external data set when you call <a>flowBoxChildChanged</a> on the
--   first child, the sort function must only read the new data for the
--   first of the two changed children, otherwise the resorting of the
--   children will be wrong.
--   
--   This generally means that if you don’t fully control the data model,
--   you have to duplicate the data that affects the sorting and filtering
--   functions into the widgets themselves. Another alternative is to call
--   <a>flowBoxInvalidateSort</a> on any model change, but that is more
--   expensive.
--   
--   <i>Since: 3.12</i>
flowBoxChildChanged :: (HasCallStack, MonadIO m, IsFlowBoxChild a) => a -> m ()

-- | Returns the horizontal scrollbar’s adjustment, used to connect the
--   horizontal scrollbar to the child widget’s horizontal scroll
--   functionality.
scrolledWindowGetHadjustment :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Adjustment

-- | Returns the vertical scrollbar’s adjustment, used to connect the
--   vertical scrollbar to the child widget’s vertical scroll
--   functionality.
scrolledWindowGetVadjustment :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Adjustment

-- | Parses <i><tt>str</tt></i> which is marked up with the [Pango text
--   markup language][PangoMarkupFormat], setting the label’s text and
--   attribute list based on the parse results.
--   
--   If the <i><tt>str</tt></i> is external data, you may need to escape it
--   with <a>markupEscapeText</a> or
--   <tt><i>g_markup_printf_escaped()</i></tt>:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GtkWidget *label = gtk_label_new (NULL);
--   const char *str = "some text";
--   const char *format = "&lt;span style=\"italic\"&gt;\%s&lt;/span&gt;";
--   char *markup;
--   
--   markup = g_markup_printf_escaped (format, str);
--   gtk_label_set_markup (GTK_LABEL (label), markup);
--   g_free (markup);
--   </pre>
--   
--   This function will set the <a>Label:useMarkup</a> property to
--   <a>True</a> as a side effect.
--   
--   If you set the label contents using the <a>Label:label</a> property
--   you should also ensure that you set the <a>Label:useMarkup</a>
--   property accordingly.
--   
--   See also: <a>labelSetText</a>
labelSetMarkup :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Adds the events in the bitfield <i><tt>events</tt></i> to the event
--   mask for <i><tt>widget</tt></i>. See <a>widgetSetEvents</a> and the
--   [input handling overview][event-masks] for details.
widgetAddEvents :: (HasCallStack, MonadIO m, IsWidget a) => a -> [EventMask] -> m ()

-- | Retrieves the maximum allowed length of the text in
--   <i><tt>buffer</tt></i>. See <a>entryBufferSetMaxLength</a>.
--   
--   <i>Since: 2.18</i>
entryBufferGetMaxLength :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m Int32

-- | Retrieves a sequence of characters. The characters that are retrieved
--   are those characters at positions from <i><tt>startPos</tt></i> up to,
--   but not including <i><tt>endPos</tt></i>. If <i><tt>endPos</tt></i> is
--   negative, then the characters retrieved are those characters from
--   <i><tt>startPos</tt></i> to the end of the text.
--   
--   Note that positions are specified in characters, not bytes.
editableGetChars :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> Int32 -> m Text

-- | Retrieves the contents of the buffer.
--   
--   The memory pointer returned by this call will not change unless this
--   object emits a signal, or is finalized.
--   
--   <i>Since: 2.18</i>
entryBufferGetText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m Text

-- | Retrieves the length in characters of the buffer.
--   
--   <i>Since: 2.18</i>
entryBufferGetLength :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m Word32

-- | Reset the input method context of the text view if needed.
--   
--   This can be necessary in the case where modifying the buffer would
--   confuse on-going input method behavior.
--   
--   <i>Since: 2.22</i>
textViewResetImContext :: (HasCallStack, MonadIO m, IsTextView a) => a -> m ()

-- | Activates the default widget for the window, unless the current
--   focused widget has been configured to receive the default action (see
--   <a>widgetSetReceivesDefault</a>), in which case the focused widget is
--   activated.
windowActivateDefault :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Sets the has-tooltip property on <i><tt>widget</tt></i> to
--   <i><tt>hasTooltip</tt></i>. See <a>Widget:hasTooltip</a> for more
--   information.
--   
--   <i>Since: 2.12</i>
widgetSetHasTooltip :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the maximum allowed length of the contents of the buffer. If the
--   current contents are longer than the given length, then they will be
--   truncated to fit.
--   
--   <i>Since: 2.18</i>
entryBufferSetMaxLength :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Int32 -> m ()

-- | Sets the text in the buffer.
--   
--   This is roughly equivalent to calling <a>entryBufferDeleteText</a> and
--   <a>entryBufferInsertText</a>.
--   
--   Note that <i><tt>nChars</tt></i> is in characters, not in bytes.
--   
--   <i>Since: 2.18</i>
entryBufferSetText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Text -> Int32 -> m ()

-- | Adds <i><tt>child</tt></i> to <i><tt>box</tt></i>, packed with
--   reference to the start of <i><tt>box</tt></i>. The
--   <i><tt>child</tt></i> is packed after any other child packed with
--   reference to the start of <i><tt>box</tt></i>.
boxPackStart :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> b -> Bool -> Bool -> Word32 -> m ()

-- | Adds a widget to the grid.
--   
--   The position of <i><tt>child</tt></i> is determined by
--   <i><tt>left</tt></i> and <i><tt>top</tt></i>. The number of “cells”
--   that <i><tt>child</tt></i> will occupy is determined by
--   <i><tt>width</tt></i> and <i><tt>height</tt></i>.
gridAttach :: (HasCallStack, MonadIO m, IsGrid a, IsWidget b) => a -> b -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Emits a <a>Widget::childNotify</a> signal for the [child
--   property][child-properties] <i><tt>childProperty</tt></i> on
--   <i><tt>widget</tt></i>.
--   
--   This is the analogue of <a>objectNotify</a> for child properties.
--   
--   Also see <a>containerChildNotify</a>.
widgetChildNotify :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> m ()

-- | Retrieves the current focused widget within the window. Note that this
--   is the widget that would have the focus if the toplevel window
--   focused; if the toplevel window is not focused then
--   <tt>gtk_widget_has_focus (widget)</tt> will not be <a>True</a> for the
--   widget.
windowGetFocus :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Widget)

-- | Draws <i><tt>widget</tt></i> to <i><tt>cr</tt></i>. The top left
--   corner of the widget will be drawn to the currently set origin point
--   of <i><tt>cr</tt></i>.
--   
--   You should pass a cairo context as <i><tt>cr</tt></i> argument that is
--   in an original state. Otherwise the resulting drawing is undefined.
--   For example changing the operator using
--   <tt><i>cairo_set_operator()</i></tt> or the line width using
--   <tt><i>cairo_set_line_width()</i></tt> might have unwanted side
--   effects. You may however change the context’s transform matrix - like
--   with <tt><i>cairo_scale()</i></tt>, <tt><i>cairo_translate()</i></tt>
--   or <tt><i>cairo_set_matrix()</i></tt> and clip region with
--   <tt><i>cairo_clip()</i></tt> prior to calling this function. Also, it
--   is fine to modify the context with <tt><i>cairo_save()</i></tt> and
--   <tt><i>cairo_push_group()</i></tt> prior to calling this function.
--   
--   Note that special-purpose widgets may contain special code for
--   rendering to the screen and might appear differently on screen and
--   when rendered using <a>widgetDraw</a>.
--   
--   <i>Since: 3.0</i>
widgetDraw :: (HasCallStack, MonadIO m, IsWidget a) => a -> Context -> m ()

-- | Unsets all the mappings on all renderers on <i><tt>cellLayout</tt></i>
--   and removes all renderers from <i><tt>cellLayout</tt></i>.
--   
--   <i>Since: 2.4</i>
cellLayoutClear :: (HasCallStack, MonadIO m, IsCellLayout a) => a -> m ()

-- | Frees a <a>SelectionData</a>-struct returned from
--   <a>selectionDataCopy</a>.
selectionDataFree :: (HasCallStack, MonadIO m) => SelectionData -> m ()

-- | Begins editing on a <i><tt>cellEditable</tt></i>.
--   
--   The <a>CellRenderer</a> for the cell creates and returns a
--   <a>CellEditable</a> from <a>cellRendererStartEditing</a>, configured
--   for the <a>CellRenderer</a> type.
--   
--   <a>cellEditableStartEditing</a> can then set up
--   <i><tt>cellEditable</tt></i> suitably for editing a cell, e.g. making
--   the Esc key emit <a>CellEditable::editingDone</a>.
--   
--   Note that the <i><tt>cellEditable</tt></i> is created on-demand for
--   the current edit; its lifetime is temporary and does not persist
--   across other edits and/or cells.
cellEditableStartEditing :: (HasCallStack, MonadIO m, IsCellEditable a) => a -> Maybe Event -> m ()

-- | Retrieves a cell area’s initial minimum and natural height.
--   
--   <i><tt>area</tt></i> will store some geometrical information in
--   <i><tt>context</tt></i> along the way; when requesting sizes over an
--   arbitrary number of rows, it’s not important to check the
--   <i><tt>minimumHeight</tt></i> and <i><tt>naturalHeight</tt></i> of
--   this call but rather to consult
--   <a>cellAreaContextGetPreferredHeight</a> after a series of requests.
--   
--   <i>Since: 3.0</i>
cellAreaGetPreferredHeight :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> m (Int32, Int32)

-- | Retrieves a cell area’s initial minimum and natural width.
--   
--   <i><tt>area</tt></i> will store some geometrical information in
--   <i><tt>context</tt></i> along the way; when requesting sizes over an
--   arbitrary number of rows, it’s not important to check the
--   <i><tt>minimumWidth</tt></i> and <i><tt>naturalWidth</tt></i> of this
--   call but rather to consult <a>cellAreaContextGetPreferredWidth</a>
--   after a series of requests.
--   
--   <i>Since: 3.0</i>
cellAreaGetPreferredWidth :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> m (Int32, Int32)

-- | Retrieves a cell area’s minimum and natural height if it would be
--   given the specified <i><tt>width</tt></i>.
--   
--   <i><tt>area</tt></i> stores some geometrical information in
--   <i><tt>context</tt></i> along the way while calling
--   <a>cellAreaGetPreferredWidth</a>. It’s important to perform a series
--   of <a>cellAreaGetPreferredWidth</a> requests with
--   <i><tt>context</tt></i> first and then call
--   <a>cellAreaGetPreferredHeightForWidth</a> on each cell area
--   individually to get the height for width of each fully requested row.
--   
--   If at some point, the width of a single row changes, it should be
--   requested with <a>cellAreaGetPreferredWidth</a> again and then the
--   full width of the requested rows checked again with
--   <a>cellAreaContextGetPreferredWidth</a>.
--   
--   <i>Since: 3.0</i>
cellAreaGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Int32 -> m (Int32, Int32)

-- | Gets the accumulative preferred height for all rows which have been
--   requested with this context.
--   
--   After <a>cellAreaContextReset</a> is called and/or before ever
--   requesting the size of a <a>CellArea</a>, the returned values are 0.
--   
--   <i>Since: 3.0</i>
cellAreaContextGetPreferredHeight :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m (Int32, Int32)

-- | Gets the accumulative preferred width for all rows which have been
--   requested with this context.
--   
--   After <a>cellAreaContextReset</a> is called and/or before ever
--   requesting the size of a <a>CellArea</a>, the returned values are 0.
--   
--   <i>Since: 3.0</i>
cellAreaContextGetPreferredWidth :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m (Int32, Int32)

-- | Sets the current keyboard focus to be at <i><tt>path</tt></i>, and
--   selects it. This is useful when you want to focus the user’s attention
--   on a particular row. If <i><tt>focusColumn</tt></i> is not
--   <a>Nothing</a>, then focus is given to the column specified by it. If
--   <i><tt>focusColumn</tt></i> and <i><tt>focusCell</tt></i> are not
--   <a>Nothing</a>, and <i><tt>focusColumn</tt></i> contains 2 or more
--   editable or activatable cells, then focus is given to the cell
--   specified by <i><tt>focusCell</tt></i>. Additionally, if
--   <i><tt>focusColumn</tt></i> is specified, and
--   <i><tt>startEditing</tt></i> is <a>True</a>, then editing should be
--   started in the specified cell. This function is often followed by
--   <i><tt>gtkWidgetGrabFocus</tt></i> (<i><tt>treeView</tt></i>) in order
--   to give keyboard focus to the widget. Please note that editing can
--   only happen when the widget is realized.
--   
--   If <i><tt>path</tt></i> is invalid for <i><tt>model</tt></i>, the
--   current cursor (if any) will be unset and the function will return
--   without failing.
--   
--   <i>Since: 2.2</i>
treeViewSetCursorOnCell :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsCellRenderer c) => a -> TreePath -> Maybe b -> Maybe c -> Bool -> m ()

-- | Sets the reading direction on a particular widget. This direction
--   controls the primary direction for widgets containing text, and also
--   the direction in which the children of a container are packed. The
--   ability to set the direction is present in order so that correct
--   localization into languages with right-to-left reading directions can
--   be done. Generally, applications will let the default reading
--   direction present, except for containers where the containers are
--   arranged in an order that is explicitly visual rather than logical
--   (such as buttons for text justification).
--   
--   If the direction is set to <a>TextDirectionNone</a>, then the value
--   set by <a>widgetSetDefaultDirection</a> will be used.
widgetSetDirection :: (HasCallStack, MonadIO m, IsWidget a) => a -> TextDirection -> m ()

-- | Returns the unique ID of the window. If the window has not yet been
--   added to a <a>Application</a>, returns <tt>0</tt>.
--   
--   <i>Since: 3.6</i>
applicationWindowGetId :: (HasCallStack, MonadIO m, IsApplicationWindow a) => a -> m Word32

-- | Reloads the list of applications.
--   
--   <i>Since: 3.0</i>
appChooserRefresh :: (HasCallStack, MonadIO m, IsAppChooser a) => a -> m ()

-- | Sets the accel path for this action. All proxy widgets associated with
--   the action will have this accel path, so that their accelerators are
--   consistent.
--   
--   Note that <i><tt>accelPath</tt></i> string will be stored in a
--   <tt><i>GQuark</i></tt>. Therefore, if you pass a static string, you
--   can save some memory by interning it first with
--   <a>internStaticString</a>.
--   
--   <i>Since: 2.4</i>
actionSetAccelPath :: (HasCallStack, MonadIO m, IsAction a) => a -> Text -> m ()

-- | Returns whether the action is effectively sensitive.
--   
--   <i>Since: 2.4</i>
actionIsSensitive :: (HasCallStack, MonadIO m, IsAction a) => a -> m Bool

-- | Returns whether the action itself is sensitive. Note that this doesn’t
--   necessarily mean effective sensitivity. See <a>actionIsSensitive</a>
--   for that.
--   
--   <i>Since: 2.4</i>
actionGetSensitive :: (HasCallStack, MonadIO m, IsAction a) => a -> m Bool

-- | Returns whether the action is effectively visible.
--   
--   <i>Since: 2.4</i>
actionIsVisible :: (HasCallStack, MonadIO m, IsAction a) => a -> m Bool

-- | Returns whether the action itself is visible. Note that this doesn’t
--   necessarily mean effective visibility. See <a>actionIsSensitive</a>
--   for that.
--   
--   <i>Since: 2.4</i>
actionGetVisible :: (HasCallStack, MonadIO m, IsAction a) => a -> m Bool

-- | Gets the related <a>Action</a> for <i><tt>activatable</tt></i>.
--   
--   <i>Since: 2.16</i>
activatableGetRelatedAction :: (HasCallStack, MonadIO m, IsActivatable a) => a -> m Action

-- | Changes the <i><tt>accelKey</tt></i> and <i><tt>accelMods</tt></i>
--   currently associated with <i><tt>accelPath</tt></i>. Due to conflicts
--   with other accelerators, a change may not always be possible,
--   <i><tt>replace</tt></i> indicates whether other accelerators may be
--   deleted to resolve such conflicts. A change will only occur if all
--   conflicts could be resolved (which might not be the case if
--   conflicting accelerators are locked). Successful changes are indicated
--   by a <a>True</a> return value.
--   
--   Note that <i><tt>accelPath</tt></i> string will be stored in a
--   <tt><i>GQuark</i></tt>. Therefore, if you pass a static string, you
--   can save some memory by interning it first with
--   <a>internStaticString</a>.
accelMapChangeEntry :: (HasCallStack, MonadIO m) => Text -> Word32 -> [ModifierType] -> Bool -> m Bool

-- | Sets an icon to be used as fallback for windows that haven't had
--   <a>windowSetIcon</a> called on them from a pixbuf.
--   
--   <i>Since: 2.4</i>
windowSetDefaultIcon :: (HasCallStack, MonadIO m, IsPixbuf a) => a -> m ()

-- | Returns the ellipsize mode used for <i><tt>toolItem</tt></i>. Custom
--   subclasses of <a>ToolItem</a> should call this function to find out
--   how text should be ellipsized.
--   
--   <i>Since: 2.20</i>
toolItemGetEllipsizeMode :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m EllipsizeMode

-- | Returns the icon size used for <i><tt>toolItem</tt></i>. Custom
--   subclasses of <a>ToolItem</a> should call this function to find out
--   what size icons they should use.
--   
--   <i>Since: 2.4</i>
toolItemGetIconSize :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Int32

-- | Returns the orientation used for <i><tt>toolItem</tt></i>. Custom
--   subclasses of <a>ToolItem</a> should call this function to find out
--   what size icons they should use.
--   
--   <i>Since: 2.4</i>
toolItemGetOrientation :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Orientation

-- | Returns the relief style of <i><tt>toolItem</tt></i>. See
--   <a>buttonSetRelief</a>. Custom subclasses of <a>ToolItem</a> should
--   call this function in the handler of the
--   <a>ToolItem</a>::<tt><i>toolbar_reconfigured</i></tt> signal to find
--   out the relief style of buttons.
--   
--   <i>Since: 2.4</i>
toolItemGetReliefStyle :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m ReliefStyle

-- | Returns the toolbar style used for <i><tt>toolItem</tt></i>. Custom
--   subclasses of <a>ToolItem</a> should call this function in the handler
--   of the GtkToolItem<a>toolbar_reconfigured</a> signal to find out in
--   what style the toolbar is displayed and change themselves accordingly
--   
--   Possibilities are:
--   
--   <ul>
--   <li><a>ToolbarStyleBoth</a>, meaning the tool item should show both an
--   icon and a label, stacked vertically</li>
--   <li><a>ToolbarStyleIcons</a>, meaning the toolbar shows only
--   icons</li>
--   <li><a>ToolbarStyleText</a>, meaning the tool item should only show
--   text</li>
--   <li><a>ToolbarStyleBothHoriz</a>, meaning the tool item should show
--   both an icon and a label, arranged horizontally</li>
--   </ul>
--   
--   <i>Since: 2.4</i>
toolItemGetToolbarStyle :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m ToolbarStyle

-- | Returns the text alignment used for <i><tt>toolItem</tt></i>. Custom
--   subclasses of <a>ToolItem</a> should call this function to find out
--   how text should be aligned.
--   
--   <i>Since: 2.20</i>
toolItemGetTextAlignment :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Float

-- | Returns the text orientation used for <i><tt>toolItem</tt></i>. Custom
--   subclasses of <a>ToolItem</a> should call this function to find out
--   how text should be orientated.
--   
--   <i>Since: 2.20</i>
toolItemGetTextOrientation :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Orientation

-- | Returns the size group used for labels in <i><tt>toolItem</tt></i>.
--   Custom subclasses of <a>ToolItem</a> should call this function and use
--   the size group for labels.
--   
--   <i>Since: 2.20</i>
toolItemGetTextSizeGroup :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m SizeGroup

-- | Calling this function signals to the toolbar that the overflow menu
--   item for <i><tt>toolItem</tt></i> has changed. If the overflow menu is
--   visible when this function it called, the menu will be rebuilt.
--   
--   The function must be called when the tool item changes what it will do
--   in response to the <a>ToolItem::createMenuProxy</a> signal.
--   
--   <i>Since: 2.6</i>
toolItemRebuildMenu :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m ()

-- | Starts editing the contents of this <i><tt>cell</tt></i>, through a
--   new <a>CellEditable</a> widget created by the
--   <a>CellRendererClass</a>.<tt><i>start_editing</i></tt> virtual
--   function.
cellRendererStartEditing :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> Maybe Event -> b -> Text -> Rectangle -> Rectangle -> [CellRendererState] -> m (Maybe CellEditable)

-- | Parses a file containing a [GtkBuilder UI definition][BUILDER-UI] and
--   merges it with the current contents of <i><tt>builder</tt></i>.
--   
--   Most users will probably want to use <a>builderNewFromFile</a>.
--   
--   If an error occurs, 0 will be returned and <i><tt>error</tt></i> will
--   be assigned a <a>GError</a> from the
--   <tt><i>GTK_BUILDER_ERROR</i></tt>, <tt><i>G_MARKUP_ERROR</i></tt> or
--   <tt><i>G_FILE_ERROR</i></tt> domain.
--   
--   It’s not really reasonable to attempt to handle failures of this call.
--   You should not use this function with untrusted files (ie: files that
--   are not part of your application). Broken <a>Builder</a> files can
--   easily crash your program, and it’s possible that memory was leaked
--   leading up to the reported failure. The only reasonable thing to do
--   when an error is detected is to call <tt><i>g_error()</i></tt>.
--   
--   <i>Since: 2.12</i>
builderAddFromFile :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> m Word32

-- | Parses a string containing a [GtkBuilder UI definition][BUILDER-UI]
--   and merges it with the current contents of <i><tt>builder</tt></i>.
--   
--   Most users will probably want to use <a>builderNewFromString</a>.
--   
--   Upon errors 0 will be returned and <i><tt>error</tt></i> will be
--   assigned a <a>GError</a> from the <tt><i>GTK_BUILDER_ERROR</i></tt>,
--   <tt><i>G_MARKUP_ERROR</i></tt> or
--   <tt><i>G_VARIANT_PARSE_ERROR</i></tt> domain.
--   
--   It’s not really reasonable to attempt to handle failures of this call.
--   The only reasonable thing to do when an error is detected is to call
--   <tt><i>g_error()</i></tt>.
--   
--   <i>Since: 2.12</i>
builderAddFromString :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> Int64 -> m Word32

-- | Gets the <a>Settings</a> object for <i><tt>screen</tt></i>, creating
--   it if necessary.
--   
--   <i>Since: 2.2</i>
settingsGetForScreen :: (HasCallStack, MonadIO m, IsScreen a) => a -> m Settings

-- | Used to set the <a>Style</a> for a widget
--   (<i><tt>widget</tt></i>-&gt;style). Since GTK 3, this function does
--   nothing, the passed in style is ignored.
widgetSetStyle :: (HasCallStack, MonadIO m, IsWidget a, IsStyle b) => a -> Maybe b -> m ()

-- | Rarely-used function. This function is used to emit the event signals
--   on a widget (those signals should never be emitted without using this
--   function to do so). If you want to synthesize an event though, don’t
--   use this function; instead, use <a>mainDoEvent</a> so the event will
--   behave as if it were in the event queue. Don’t synthesize expose
--   events; instead, use <a>windowInvalidateRect</a> to invalidate a
--   region of the window.
widgetEvent :: (HasCallStack, MonadIO m, IsWidget a) => a -> Event -> m Bool

-- | Equivalent to calling <a>widgetQueueDrawArea</a> for the entire area
--   of a widget.
widgetQueueDraw :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Obtains the current default reading direction. See
--   <a>widgetSetDefaultDirection</a>.
widgetGetDefaultDirection :: (HasCallStack, MonadIO m) => m TextDirection

-- | Initiates a drag on the source side. The function only needs to be
--   used when the application is starting drags itself, and is not needed
--   when <a>widgetDragSourceSet</a> is used.
--   
--   The <i><tt>event</tt></i> is used to retrieve the timestamp that will
--   be used internally to grab the pointer. If <i><tt>event</tt></i> is
--   <a>Nothing</a>, then <a>CURRENT_TIME</a> will be used. However, you
--   should try to pass a real event in all cases, since that can be used
--   to get information about the drag.
--   
--   Generally there are three cases when you want to start a drag by hand
--   by calling this function:
--   
--   <ol>
--   <li>During a <a>Widget::buttonPressEvent</a> handler, if you want to
--   start a drag immediately when the user presses the mouse button. Pass
--   the <i><tt>event</tt></i> that you have in your
--   <a>Widget::buttonPressEvent</a> handler.</li>
--   <li>During a <a>Widget::motionNotifyEvent</a> handler, if you want to
--   start a drag when the mouse moves past a certain threshold distance
--   after a button-press. Pass the <i><tt>event</tt></i> that you have in
--   your <a>Widget::motionNotifyEvent</a> handler.</li>
--   <li>During a timeout handler, if you want to start a drag after the
--   mouse button is held down for some time. Try to save the last event
--   that you got from the mouse, using <a>eventCopy</a>, and pass it to
--   this function (remember to free the event with <a>eventFree</a> when
--   you are done). If you really cannot pass a real event, pass
--   <a>Nothing</a> instead.</li>
--   </ol>
--   
--   <i>Since: 3.10</i>
widgetDragBeginWithCoordinates :: (HasCallStack, MonadIO m, IsWidget a) => a -> TargetList -> [DragAction] -> Int32 -> Maybe Event -> Int32 -> Int32 -> m DragContext

-- | Catch exceptions of type <a>RecentManagerError</a>. This is a
--   specialized version of <a>catchGErrorJustDomain</a>.
catchRecentManagerError :: IO a -> (RecentManagerError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>RecentManagerError</a>. This is a
--   specialized version of <a>handleGErrorJustDomain</a>.
handleRecentManagerError :: (RecentManagerError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Catch exceptions of type <a>RecentChooserError</a>. This is a
--   specialized version of <a>catchGErrorJustDomain</a>.
catchRecentChooserError :: IO a -> (RecentChooserError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>RecentChooserError</a>. This is a
--   specialized version of <a>handleGErrorJustDomain</a>.
handleRecentChooserError :: (RecentChooserError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Catch exceptions of type <a>PrintError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchPrintError :: IO a -> (PrintError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>PrintError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handlePrintError :: (PrintError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Catch exceptions of type <a>IconThemeError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchIconThemeError :: IO a -> (IconThemeError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>IconThemeError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleIconThemeError :: (IconThemeError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Catch exceptions of type <a>FileChooserError</a>. This is a
--   specialized version of <a>catchGErrorJustDomain</a>.
catchFileChooserError :: IO a -> (FileChooserError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>FileChooserError</a>. This is a
--   specialized version of <a>handleGErrorJustDomain</a>.
handleFileChooserError :: (FileChooserError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Catch exceptions of type <a>CssProviderError</a>. This is a
--   specialized version of <a>catchGErrorJustDomain</a>.
catchCssProviderError :: IO a -> (CssProviderError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>CssProviderError</a>. This is a
--   specialized version of <a>handleGErrorJustDomain</a>.
handleCssProviderError :: (CssProviderError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Catch exceptions of type <a>BuilderError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchBuilderError :: IO a -> (BuilderError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>BuilderError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleBuilderError :: (BuilderError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Cast to <a>ColorChooser</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toColorChooser :: (MonadIO m, IsColorChooser o) => o -> m ColorChooser

-- | Get the value of the “<tt>rgba</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorChooser #rgba
--   </pre>
getColorChooserRgba :: (MonadIO m, IsColorChooser o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>rgba</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorChooser [ #rgba <a>:=</a> value ]
--   </pre>
setColorChooserRgba :: (MonadIO m, IsColorChooser o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rgba</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColorChooserRgba :: (IsColorChooser o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-alpha</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorChooser #useAlpha
--   </pre>
getColorChooserUseAlpha :: (MonadIO m, IsColorChooser o) => o -> m Bool

-- | Set the value of the “<tt>use-alpha</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorChooser [ #useAlpha <a>:=</a> value ]
--   </pre>
setColorChooserUseAlpha :: (MonadIO m, IsColorChooser o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-alpha</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructColorChooserUseAlpha :: (IsColorChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Adds a palette to the color chooser. If <i><tt>orientation</tt></i> is
--   horizontal, the colors are grouped in rows, with
--   <i><tt>colorsPerLine</tt></i> colors in each row. If
--   <i><tt>horizontal</tt></i> is <a>False</a>, the colors are grouped in
--   columns instead.
--   
--   The default color palette of <a>ColorChooserWidget</a> has 27 colors,
--   organized in columns of 3 colors. The default gray palette has 9 grays
--   in a single row.
--   
--   The layout of the color chooser widget works best when the palettes
--   have 9-10 columns.
--   
--   Calling this function for the first time has the side effect of
--   removing the default color and gray palettes from the color chooser.
--   
--   If <i><tt>colors</tt></i> is <a>Nothing</a>, removes all previously
--   added palettes.
--   
--   <i>Since: 3.4</i>
colorChooserAddPalette :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> Orientation -> Int32 -> Maybe [RGBA] -> m ()

-- | Gets the currently-selected color.
--   
--   <i>Since: 3.4</i>
colorChooserGetRgba :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> m RGBA

-- | Returns whether the color chooser shows the alpha channel.
--   
--   <i>Since: 3.4</i>
colorChooserGetUseAlpha :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> m Bool

-- | Sets the color.
--   
--   <i>Since: 3.4</i>
colorChooserSetRgba :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> RGBA -> m ()

-- | Sets whether or not the color chooser should use the alpha channel.
--   
--   <i>Since: 3.4</i>
colorChooserSetUseAlpha :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> Bool -> m ()

-- | Connect a signal handler for the <a>colorActivated</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> colorChooser #colorActivated callback
--   </pre>
onColorChooserColorActivated :: (IsColorChooser a, MonadIO m) => a -> ((?self :: a) => ColorChooserColorActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>colorActivated</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> colorChooser #colorActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterColorChooserColorActivated :: (IsColorChooser a, MonadIO m) => a -> ((?self :: a) => ColorChooserColorActivatedCallback) -> m SignalHandlerId

-- | Cast to <a>Editable</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toEditable :: (MonadIO m, IsEditable o) => o -> m Editable

-- | Copies the contents of the currently selected content in the editable
--   and puts it on the clipboard.
editableCopyClipboard :: (HasCallStack, MonadIO m, IsEditable a) => a -> m ()

-- | Removes the contents of the currently selected content in the editable
--   and puts it on the clipboard.
editableCutClipboard :: (HasCallStack, MonadIO m, IsEditable a) => a -> m ()

-- | Deletes the currently selected text of the editable. This call doesn’t
--   do anything if there is no selected text.
editableDeleteSelection :: (HasCallStack, MonadIO m, IsEditable a) => a -> m ()

-- | Deletes a sequence of characters. The characters that are deleted are
--   those characters at positions from <i><tt>startPos</tt></i> up to, but
--   not including <i><tt>endPos</tt></i>. If <i><tt>endPos</tt></i> is
--   negative, then the characters deleted are those from
--   <i><tt>startPos</tt></i> to the end of the text.
--   
--   Note that the positions are specified in characters, not bytes.
editableDeleteText :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> Int32 -> m ()

-- | Retrieves whether <i><tt>editable</tt></i> is editable. See
--   <a>editableSetEditable</a>.
editableGetEditable :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Bool

-- | Retrieves the current position of the cursor relative to the start of
--   the content of the editable.
--   
--   Note that this position is in characters, not in bytes.
editableGetPosition :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Int32

-- | Retrieves the selection bound of the editable. start_pos will be
--   filled with the start of the selection and <i><tt>endPos</tt></i> with
--   end. If no text was selected both will be identical and <a>False</a>
--   will be returned.
--   
--   Note that positions are specified in characters, not bytes.
editableGetSelectionBounds :: (HasCallStack, MonadIO m, IsEditable a) => a -> m (Bool, Int32, Int32)

-- | Inserts <i><tt>newTextLength</tt></i> bytes of <i><tt>newText</tt></i>
--   into the contents of the widget, at position <i><tt>position</tt></i>.
--   
--   Note that the position is in characters, not in bytes. The function
--   updates <i><tt>position</tt></i> to point after the newly inserted
--   text.
editableInsertText :: (HasCallStack, MonadIO m, IsEditable a) => a -> Text -> Int32 -> Int32 -> m Int32

-- | Pastes the content of the clipboard to the current position of the
--   cursor in the editable.
editablePasteClipboard :: (HasCallStack, MonadIO m, IsEditable a) => a -> m ()

-- | Selects a region of text. The characters that are selected are those
--   characters at positions from <i><tt>startPos</tt></i> up to, but not
--   including <i><tt>endPos</tt></i>. If <i><tt>endPos</tt></i> is
--   negative, then the characters selected are those characters from
--   <i><tt>startPos</tt></i> to the end of the text.
--   
--   Note that positions are specified in characters, not bytes.
editableSelectRegion :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> Int32 -> m ()

-- | Determines if the user can edit the text in the editable widget or
--   not.
editableSetEditable :: (HasCallStack, MonadIO m, IsEditable a) => a -> Bool -> m ()

-- | Sets the cursor position in the editable to the given value.
--   
--   The cursor is displayed before the character with the given (base 0)
--   index in the contents of the editable. The value must be less than or
--   equal to the number of characters in the editable. A value of -1
--   indicates that the position should be set after the last character of
--   the editable. Note that <i><tt>position</tt></i> is in characters, not
--   in bytes.
editableSetPosition :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> m ()

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> editable #changed callback
--   </pre>
onEditableChanged :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> editable #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEditableChanged :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteText</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> editable #deleteText callback
--   </pre>
onEditableDeleteText :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableDeleteTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteText</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> editable #deleteText callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEditableDeleteText :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableDeleteTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertText</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> editable #insertText callback
--   </pre>
onEditableInsertText :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableInsertTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertText</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> editable #insertText callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEditableInsertText :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableInsertTextCallback) -> m SignalHandlerId

-- | Cast to <a>Orientable</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toOrientable :: (MonadIO m, IsOrientable o) => o -> m Orientable

-- | Get the value of the “<tt>orientation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> orientable #orientation
--   </pre>
getOrientableOrientation :: (MonadIO m, IsOrientable o) => o -> m Orientation

-- | Set the value of the “<tt>orientation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> orientable [ #orientation <a>:=</a> value ]
--   </pre>
setOrientableOrientation :: (MonadIO m, IsOrientable o) => o -> Orientation -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>orientation</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructOrientableOrientation :: (IsOrientable o, MonadIO m) => Orientation -> m (GValueConstruct o)

-- | Retrieves the orientation of the <i><tt>orientable</tt></i>.
--   
--   <i>Since: 2.16</i>
orientableGetOrientation :: (HasCallStack, MonadIO m, IsOrientable a) => a -> m Orientation

-- | Sets the orientation of the <i><tt>orientable</tt></i>.
--   
--   <i>Since: 2.16</i>
orientableSetOrientation :: (HasCallStack, MonadIO m, IsOrientable a) => a -> Orientation -> m ()

-- | Cast to <a>Adjustment</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAdjustment :: (MonadIO m, IsAdjustment o) => o -> m Adjustment

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> adjustment #changed callback
--   </pre>
onAdjustmentChanged :: (IsAdjustment a, MonadIO m) => a -> ((?self :: a) => AdjustmentChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> adjustment #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAdjustmentChanged :: (IsAdjustment a, MonadIO m) => a -> ((?self :: a) => AdjustmentChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>valueChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> adjustment #valueChanged callback
--   </pre>
onAdjustmentValueChanged :: (IsAdjustment a, MonadIO m) => a -> ((?self :: a) => AdjustmentValueChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>valueChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> adjustment #valueChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAdjustmentValueChanged :: (IsAdjustment a, MonadIO m) => a -> ((?self :: a) => AdjustmentValueChangedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>lower</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> adjustment #lower
--   </pre>
getAdjustmentLower :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “<tt>lower</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> adjustment [ #lower <a>:=</a> value ]
--   </pre>
setAdjustmentLower :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>lower</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAdjustmentLower :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>page-increment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> adjustment #pageIncrement
--   </pre>
getAdjustmentPageIncrement :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “<tt>page-increment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> adjustment [ #pageIncrement <a>:=</a> value ]
--   </pre>
setAdjustmentPageIncrement :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>page-increment</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAdjustmentPageIncrement :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>page-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> adjustment #pageSize
--   </pre>
getAdjustmentPageSize :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “<tt>page-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> adjustment [ #pageSize <a>:=</a> value ]
--   </pre>
setAdjustmentPageSize :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>page-size</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructAdjustmentPageSize :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>step-increment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> adjustment #stepIncrement
--   </pre>
getAdjustmentStepIncrement :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “<tt>step-increment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> adjustment [ #stepIncrement <a>:=</a> value ]
--   </pre>
setAdjustmentStepIncrement :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>step-increment</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAdjustmentStepIncrement :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>upper</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> adjustment #upper
--   </pre>
getAdjustmentUpper :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “<tt>upper</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> adjustment [ #upper <a>:=</a> value ]
--   </pre>
setAdjustmentUpper :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>upper</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAdjustmentUpper :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> adjustment #value
--   </pre>
getAdjustmentValue :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> adjustment [ #value <a>:=</a> value ]
--   </pre>
setAdjustmentValue :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>value</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAdjustmentValue :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Creates a new <a>Adjustment</a>.
adjustmentNew :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> Double -> Double -> Double -> m Adjustment

-- | Emits a <a>Adjustment::changed</a> signal from the <a>Adjustment</a>.
--   This is typically called by the owner of the <a>Adjustment</a> after
--   it has changed any of the <a>Adjustment</a> properties other than the
--   value.
adjustmentChanged :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m ()

-- | Updates the <a>Adjustment:value</a> property to ensure that the range
--   between <i><tt>lower</tt></i> and <i><tt>upper</tt></i> is in the
--   current page (i.e. between <a>Adjustment:value</a> and
--   <a>Adjustment:value</a> + <a>Adjustment:pageSize</a>). If the range is
--   larger than the page size, then only the start of it will be in the
--   current page.
--   
--   A <a>Adjustment::valueChanged</a> signal will be emitted if the value
--   is changed.
adjustmentClampPage :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> Double -> m ()

-- | Sets all properties of the adjustment at once.
--   
--   Use this function to avoid multiple emissions of the
--   <a>Adjustment::changed</a> signal. See <a>adjustmentSetLower</a> for
--   an alternative way of compressing multiple emissions of
--   <a>Adjustment::changed</a> into one.
--   
--   <i>Since: 2.14</i>
adjustmentConfigure :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> Double -> Double -> Double -> Double -> Double -> m ()

-- | Retrieves the minimum value of the adjustment.
--   
--   <i>Since: 2.14</i>
adjustmentGetLower :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Gets the smaller of step increment and page increment.
--   
--   <i>Since: 3.2</i>
adjustmentGetMinimumIncrement :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Retrieves the page increment of the adjustment.
--   
--   <i>Since: 2.14</i>
adjustmentGetPageIncrement :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Retrieves the page size of the adjustment.
--   
--   <i>Since: 2.14</i>
adjustmentGetPageSize :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Retrieves the step increment of the adjustment.
--   
--   <i>Since: 2.14</i>
adjustmentGetStepIncrement :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Retrieves the maximum value of the adjustment.
--   
--   <i>Since: 2.14</i>
adjustmentGetUpper :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Gets the current value of the adjustment. See
--   <a>adjustmentSetValue</a>.
adjustmentGetValue :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Sets the minimum value of the adjustment.
--   
--   When setting multiple adjustment properties via their individual
--   setters, multiple <a>Adjustment::changed</a> signals will be emitted.
--   However, since the emission of the <a>Adjustment::changed</a> signal
--   is tied to the emission of the <a>Object::notify</a> signals of the
--   changed properties, it’s possible to compress the
--   <a>Adjustment::changed</a> signals into one by calling
--   <a>objectFreezeNotify</a> and <a>objectThawNotify</a> around the calls
--   to the individual setters.
--   
--   Alternatively, using a single <tt><i>g_object_set()</i></tt> for all
--   the properties to change, or using <a>adjustmentConfigure</a> has the
--   same effect of compressing <a>Adjustment::changed</a> emissions.
--   
--   <i>Since: 2.14</i>
adjustmentSetLower :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Sets the page increment of the adjustment.
--   
--   See <a>adjustmentSetLower</a> about how to compress multiple emissions
--   of the <a>Adjustment::changed</a> signal when setting multiple
--   adjustment properties.
--   
--   <i>Since: 2.14</i>
adjustmentSetPageIncrement :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Sets the page size of the adjustment.
--   
--   See <a>adjustmentSetLower</a> about how to compress multiple emissions
--   of the GtkAdjustment<a>changed</a> signal when setting multiple
--   adjustment properties.
--   
--   <i>Since: 2.14</i>
adjustmentSetPageSize :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Sets the step increment of the adjustment.
--   
--   See <a>adjustmentSetLower</a> about how to compress multiple emissions
--   of the <a>Adjustment::changed</a> signal when setting multiple
--   adjustment properties.
--   
--   <i>Since: 2.14</i>
adjustmentSetStepIncrement :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Sets the maximum value of the adjustment.
--   
--   Note that values will be restricted by <tt>upper - page-size</tt> if
--   the page-size property is nonzero.
--   
--   See <a>adjustmentSetLower</a> about how to compress multiple emissions
--   of the <a>Adjustment::changed</a> signal when setting multiple
--   adjustment properties.
--   
--   <i>Since: 2.14</i>
adjustmentSetUpper :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Sets the <a>Adjustment</a> value. The value is clamped to lie between
--   <a>Adjustment:lower</a> and <a>Adjustment:upper</a>.
--   
--   Note that for adjustments which are used in a <a>Scrollbar</a>, the
--   effective range of allowed values goes from <a>Adjustment:lower</a> to
--   <a>Adjustment:upper</a> - <a>Adjustment:pageSize</a>.
adjustmentSetValue :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Emits a <a>Adjustment::valueChanged</a> signal from the
--   <a>Adjustment</a>. This is typically called by the owner of the
--   <a>Adjustment</a> after it has changed the <a>Adjustment:value</a>
--   property.
adjustmentValueChanged :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m ()

-- | Cast to <a>EntryBuffer</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toEntryBuffer :: (MonadIO m, IsEntryBuffer o) => o -> m EntryBuffer

-- | Connect a signal handler for the <a>deletedText</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entryBuffer #deletedText callback
--   </pre>
onEntryBufferDeletedText :: (IsEntryBuffer a, MonadIO m) => a -> ((?self :: a) => EntryBufferDeletedTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deletedText</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entryBuffer #deletedText callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryBufferDeletedText :: (IsEntryBuffer a, MonadIO m) => a -> ((?self :: a) => EntryBufferDeletedTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertedText</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entryBuffer #insertedText callback
--   </pre>
onEntryBufferInsertedText :: (IsEntryBuffer a, MonadIO m) => a -> ((?self :: a) => EntryBufferInsertedTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertedText</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entryBuffer #insertedText callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryBufferInsertedText :: (IsEntryBuffer a, MonadIO m) => a -> ((?self :: a) => EntryBufferInsertedTextCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryBuffer #length
--   </pre>
getEntryBufferLength :: (MonadIO m, IsEntryBuffer o) => o -> m Word32

-- | Get the value of the “<tt>max-length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryBuffer #maxLength
--   </pre>
getEntryBufferMaxLength :: (MonadIO m, IsEntryBuffer o) => o -> m Int32

-- | Set the value of the “<tt>max-length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryBuffer [ #maxLength <a>:=</a> value ]
--   </pre>
setEntryBufferMaxLength :: (MonadIO m, IsEntryBuffer o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-length</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryBufferMaxLength :: (IsEntryBuffer o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryBuffer #text
--   </pre>
getEntryBufferText :: (MonadIO m, IsEntryBuffer o) => o -> m Text

-- | Set the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryBuffer [ #text <a>:=</a> value ]
--   </pre>
setEntryBufferText :: (MonadIO m, IsEntryBuffer o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEntryBufferText :: (IsEntryBuffer o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>text</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #text
--   </pre>
clearEntryBufferText :: (MonadIO m, IsEntryBuffer o) => o -> m ()

-- | Create a new GtkEntryBuffer object.
--   
--   Optionally, specify initial text to set in the buffer.
--   
--   <i>Since: 2.18</i>
entryBufferNew :: (HasCallStack, MonadIO m) => Maybe Text -> Int32 -> m EntryBuffer

-- | Deletes a sequence of characters from the buffer.
--   <i><tt>nChars</tt></i> characters are deleted starting at
--   <i><tt>position</tt></i>. If <i><tt>nChars</tt></i> is negative, then
--   all characters until the end of the text are deleted.
--   
--   If <i><tt>position</tt></i> or <i><tt>nChars</tt></i> are out of
--   bounds, then they are coerced to sane values.
--   
--   Note that the positions are specified in characters, not bytes.
--   
--   <i>Since: 2.18</i>
entryBufferDeleteText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Word32 -> Int32 -> m Word32

-- | Used when subclassing <a>EntryBuffer</a>
--   
--   <i>Since: 2.18</i>
entryBufferEmitDeletedText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Word32 -> Word32 -> m ()

-- | Used when subclassing <a>EntryBuffer</a>
--   
--   <i>Since: 2.18</i>
entryBufferEmitInsertedText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Word32 -> Text -> Word32 -> m ()

-- | Retrieves the length in bytes of the buffer. See
--   <a>entryBufferGetLength</a>.
--   
--   <i>Since: 2.18</i>
entryBufferGetBytes :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m CSize

-- | Inserts <i><tt>nChars</tt></i> characters of <i><tt>chars</tt></i>
--   into the contents of the buffer, at position <i><tt>position</tt></i>.
--   
--   If <i><tt>nChars</tt></i> is negative, then characters from chars will
--   be inserted until a null-terminator is found. If
--   <i><tt>position</tt></i> or <i><tt>nChars</tt></i> are out of bounds,
--   or the maximum buffer text length is exceeded, then they are coerced
--   to sane values.
--   
--   Note that the position and length are in characters, not in bytes.
--   
--   <i>Since: 2.18</i>
entryBufferInsertText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Word32 -> Text -> Int32 -> m Word32

-- | Cast to <a>EntryIconAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toEntryIconAccessible :: (MonadIO m, IsEntryIconAccessible o) => o -> m EntryIconAccessible

-- | Cast to <a>IMContext</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toIMContext :: (MonadIO m, IsIMContext o) => o -> m IMContext

-- | Connect a signal handler for the <a>commit</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> iMContext #commit callback
--   </pre>
onIMContextCommit :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextCommitCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>commit</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> iMContext #commit callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIMContextCommit :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextCommitCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteSurrounding</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iMContext #deleteSurrounding callback
--   </pre>
onIMContextDeleteSurrounding :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextDeleteSurroundingCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteSurrounding</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iMContext #deleteSurrounding callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIMContextDeleteSurrounding :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextDeleteSurroundingCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preeditChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iMContext #preeditChanged callback
--   </pre>
onIMContextPreeditChanged :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preeditChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iMContext #preeditChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIMContextPreeditChanged :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preeditEnd</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> iMContext #preeditEnd callback
--   </pre>
onIMContextPreeditEnd :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preeditEnd</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> iMContext #preeditEnd callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIMContextPreeditEnd :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preeditStart</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> iMContext #preeditStart callback
--   </pre>
onIMContextPreeditStart :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditStartCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preeditStart</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> iMContext #preeditStart callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIMContextPreeditStart :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditStartCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>retrieveSurrounding</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iMContext #retrieveSurrounding callback
--   </pre>
onIMContextRetrieveSurrounding :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextRetrieveSurroundingCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>retrieveSurrounding</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iMContext #retrieveSurrounding callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIMContextRetrieveSurrounding :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextRetrieveSurroundingCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>input-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iMContext #inputHints
--   </pre>
getIMContextInputHints :: (MonadIO m, IsIMContext o) => o -> m [InputHints]

-- | Set the value of the “<tt>input-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iMContext [ #inputHints <a>:=</a> value ]
--   </pre>
setIMContextInputHints :: (MonadIO m, IsIMContext o) => o -> [InputHints] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-hints</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIMContextInputHints :: (IsIMContext o, MonadIO m) => [InputHints] -> m (GValueConstruct o)

-- | Get the value of the “<tt>input-purpose</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iMContext #inputPurpose
--   </pre>
getIMContextInputPurpose :: (MonadIO m, IsIMContext o) => o -> m InputPurpose

-- | Set the value of the “<tt>input-purpose</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iMContext [ #inputPurpose <a>:=</a> value ]
--   </pre>
setIMContextInputPurpose :: (MonadIO m, IsIMContext o) => o -> InputPurpose -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-purpose</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIMContextInputPurpose :: (IsIMContext o, MonadIO m) => InputPurpose -> m (GValueConstruct o)

-- | Asks the widget that the input context is attached to to delete
--   characters around the cursor position by emitting the
--   GtkIMContext<a>delete_surrounding</a> signal. Note that
--   <i><tt>offset</tt></i> and <i><tt>nChars</tt></i> are in characters
--   not in bytes which differs from the usage other places in
--   <a>IMContext</a>.
--   
--   In order to use this function, you should first call
--   <a>iMContextGetSurrounding</a> to get the current context, and call
--   this function immediately afterwards to make sure that you know what
--   you are deleting. You should also account for the fact that even if
--   the signal was handled, the input context might not have deleted all
--   the characters that were requested to be deleted.
--   
--   This function is used by an input method that wants to make
--   subsitutions in the existing text in response to new input. It is not
--   useful for applications.
iMContextDeleteSurrounding :: (HasCallStack, MonadIO m, IsIMContext a) => a -> Int32 -> Int32 -> m Bool

-- | Notify the input method that the widget to which this input context
--   corresponds has gained focus. The input method may, for example,
--   change the displayed feedback to reflect this change.
iMContextFocusIn :: (HasCallStack, MonadIO m, IsIMContext a) => a -> m ()

-- | Notify the input method that the widget to which this input context
--   corresponds has lost focus. The input method may, for example, change
--   the displayed feedback or reset the contexts state to reflect this
--   change.
iMContextFocusOut :: (HasCallStack, MonadIO m, IsIMContext a) => a -> m ()

-- | Retrieve the current preedit string for the input context, and a list
--   of attributes to apply to the string. This string should be displayed
--   inserted at the insertion point.
iMContextGetPreeditString :: (HasCallStack, MonadIO m, IsIMContext a) => a -> m (Text, AttrList, Int32)

-- | Retrieves context around the insertion point. Input methods typically
--   want context in order to constrain input text based on existing text;
--   this is important for languages such as Thai where only some sequences
--   of characters are allowed.
--   
--   This function is implemented by emitting the
--   GtkIMContext<a>retrieve_surrounding</a> signal on the input method; in
--   response to this signal, a widget should provide as much context as is
--   available, up to an entire paragraph, by calling
--   <a>iMContextSetSurrounding</a>. Note that there is no obligation for a
--   widget to respond to the <a>retrieve_surrounding</a> signal, so input
--   methods must be prepared to function without context.
iMContextGetSurrounding :: (HasCallStack, MonadIO m, IsIMContext a) => a -> m (Bool, Text, Int32)

-- | Notify the input method that a change such as a change in cursor
--   position has been made. This will typically cause the input method to
--   clear the preedit state.
iMContextReset :: (HasCallStack, MonadIO m, IsIMContext a) => a -> m ()

-- | Set the client window for the input context; this is the <a>Window</a>
--   in which the input appears. This window is used in order to correctly
--   position status windows, and may also be used for purposes internal to
--   the input method.
iMContextSetClientWindow :: (HasCallStack, MonadIO m, IsIMContext a, IsWindow b) => a -> Maybe b -> m ()

-- | Notify the input method that a change in cursor position has been
--   made. The location is relative to the client window.
iMContextSetCursorLocation :: (HasCallStack, MonadIO m, IsIMContext a) => a -> Rectangle -> m ()

-- | Sets surrounding context around the insertion point and preedit
--   string. This function is expected to be called in response to the
--   GtkIMContext<a>retrieve_surrounding</a> signal, and will likely have
--   no effect if called at other times.
iMContextSetSurrounding :: (HasCallStack, MonadIO m, IsIMContext a) => a -> Text -> Int32 -> Int32 -> m ()

-- | Sets whether the IM context should use the preedit string to display
--   feedback. If <i><tt>usePreedit</tt></i> is FALSE (default is TRUE),
--   then the IM context may use some other method to display feedback,
--   such as displaying it in a child of the root window.
iMContextSetUsePreedit :: (HasCallStack, MonadIO m, IsIMContext a) => a -> Bool -> m ()

-- | Cast to <a>IMContextSimple</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toIMContextSimple :: (MonadIO m, IsIMContextSimple o) => o -> m IMContextSimple

-- | Creates a new <a>IMContextSimple</a>.
iMContextSimpleNew :: (HasCallStack, MonadIO m) => m IMContextSimple

-- | Adds an additional table from the X11 compose file.
iMContextSimpleAddComposeFile :: (HasCallStack, MonadIO m, IsIMContextSimple a) => a -> Text -> m ()

-- | Cast to <a>RcStyle</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toRcStyle :: (MonadIO m, IsRcStyle o) => o -> m RcStyle

-- | Creates a new <a>RcStyle</a> with no fields set and a reference count
--   of 1.
rcStyleNew :: (HasCallStack, MonadIO m) => m RcStyle

-- | Makes a copy of the specified <a>RcStyle</a>. This function will
--   correctly copy an RC style that is a member of a class derived from
--   <a>RcStyle</a>.
rcStyleCopy :: (HasCallStack, MonadIO m, IsRcStyle a) => a -> m RcStyle

-- | Construct a <a>AccelKey</a> struct initialized to zero.
newZeroAccelKey :: MonadIO m => m AccelKey

-- | Get the value of the “<tt>accel_key</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> accelKey #accelKey
--   </pre>
getAccelKeyAccelKey :: MonadIO m => AccelKey -> m Word32

-- | Set the value of the “<tt>accel_key</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> accelKey [ #accelKey <a>:=</a> value ]
--   </pre>
setAccelKeyAccelKey :: MonadIO m => AccelKey -> Word32 -> m ()

-- | Get the value of the “<tt>accel_mods</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> accelKey #accelMods
--   </pre>
getAccelKeyAccelMods :: MonadIO m => AccelKey -> m [ModifierType]

-- | Set the value of the “<tt>accel_mods</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> accelKey [ #accelMods <a>:=</a> value ]
--   </pre>
setAccelKeyAccelMods :: MonadIO m => AccelKey -> [ModifierType] -> m ()

-- | Get the value of the “<tt>accel_flags</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> accelKey #accelFlags
--   </pre>
getAccelKeyAccelFlags :: MonadIO m => AccelKey -> m Word32

-- | Set the value of the “<tt>accel_flags</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> accelKey [ #accelFlags <a>:=</a> value ]
--   </pre>
setAccelKeyAccelFlags :: MonadIO m => AccelKey -> Word32 -> m ()

-- | Construct a <a>AccelGroupEntry</a> struct initialized to zero.
newZeroAccelGroupEntry :: MonadIO m => m AccelGroupEntry

-- | Get the value of the “<tt>key</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> accelGroupEntry #key
--   </pre>
getAccelGroupEntryKey :: MonadIO m => AccelGroupEntry -> m AccelKey

-- | Get the value of the “<tt>closure</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> accelGroupEntry #closure
--   </pre>
getAccelGroupEntryClosure :: MonadIO m => AccelGroupEntry -> m (Maybe (GClosure ()))

-- | Set the value of the “<tt>closure</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> accelGroupEntry [ #closure <a>:=</a> value ]
--   </pre>
setAccelGroupEntryClosure :: MonadIO m => AccelGroupEntry -> Ptr (GClosure ()) -> m ()

-- | Set the value of the “<tt>closure</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #closure
--   </pre>
clearAccelGroupEntryClosure :: MonadIO m => AccelGroupEntry -> m ()

-- | Get the value of the “<tt>accel_path_quark</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> accelGroupEntry #accelPathQuark
--   </pre>
getAccelGroupEntryAccelPathQuark :: MonadIO m => AccelGroupEntry -> m Word32

-- | Set the value of the “<tt>accel_path_quark</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> accelGroupEntry [ #accelPathQuark <a>:=</a> value ]
--   </pre>
setAccelGroupEntryAccelPathQuark :: MonadIO m => AccelGroupEntry -> Word32 -> m ()

-- | Construct a <a>ActionEntry</a> struct initialized to zero.
newZeroActionEntry :: MonadIO m => m ActionEntry

-- | Get the value of the “<tt>name</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionEntry #name
--   </pre>
getActionEntryName :: MonadIO m => ActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>name</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionEntry [ #name <a>:=</a> value ]
--   </pre>
setActionEntryName :: MonadIO m => ActionEntry -> CString -> m ()

-- | Set the value of the “<tt>name</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #name
--   </pre>
clearActionEntryName :: MonadIO m => ActionEntry -> m ()

-- | Get the value of the “<tt>stock_id</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionEntry #stockId
--   </pre>
getActionEntryStockId :: MonadIO m => ActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>stock_id</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionEntry [ #stockId <a>:=</a> value ]
--   </pre>
setActionEntryStockId :: MonadIO m => ActionEntry -> CString -> m ()

-- | Set the value of the “<tt>stock_id</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #stockId
--   </pre>
clearActionEntryStockId :: MonadIO m => ActionEntry -> m ()

-- | Get the value of the “<tt>label</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionEntry #label
--   </pre>
getActionEntryLabel :: MonadIO m => ActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>label</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionEntry [ #label <a>:=</a> value ]
--   </pre>
setActionEntryLabel :: MonadIO m => ActionEntry -> CString -> m ()

-- | Set the value of the “<tt>label</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #label
--   </pre>
clearActionEntryLabel :: MonadIO m => ActionEntry -> m ()

-- | Get the value of the “<tt>accelerator</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionEntry #accelerator
--   </pre>
getActionEntryAccelerator :: MonadIO m => ActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>accelerator</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionEntry [ #accelerator <a>:=</a> value ]
--   </pre>
setActionEntryAccelerator :: MonadIO m => ActionEntry -> CString -> m ()

-- | Set the value of the “<tt>accelerator</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #accelerator
--   </pre>
clearActionEntryAccelerator :: MonadIO m => ActionEntry -> m ()

-- | Get the value of the “<tt>tooltip</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionEntry #tooltip
--   </pre>
getActionEntryTooltip :: MonadIO m => ActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>tooltip</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionEntry [ #tooltip <a>:=</a> value ]
--   </pre>
setActionEntryTooltip :: MonadIO m => ActionEntry -> CString -> m ()

-- | Set the value of the “<tt>tooltip</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #tooltip
--   </pre>
clearActionEntryTooltip :: MonadIO m => ActionEntry -> m ()

-- | Get the value of the “<tt>callback</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionEntry #callback
--   </pre>
getActionEntryCallback :: MonadIO m => ActionEntry -> m (Maybe Callback)

-- | Set the value of the “<tt>callback</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionEntry [ #callback <a>:=</a> value ]
--   </pre>
setActionEntryCallback :: MonadIO m => ActionEntry -> FunPtr C_Callback -> m ()

-- | Set the value of the “<tt>callback</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #callback
--   </pre>
clearActionEntryCallback :: MonadIO m => ActionEntry -> m ()

-- | Construct a <a>BindingArg</a> struct initialized to zero.
newZeroBindingArg :: MonadIO m => m BindingArg

-- | Get the value of the “<tt>arg_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingArg #argType
--   </pre>
getBindingArgArgType :: MonadIO m => BindingArg -> m GType

-- | Set the value of the “<tt>arg_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingArg [ #argType <a>:=</a> value ]
--   </pre>
setBindingArgArgType :: MonadIO m => BindingArg -> GType -> m ()

-- | Construct a <a>BindingSignal</a> struct initialized to zero.
newZeroBindingSignal :: MonadIO m => m BindingSignal

-- | Get the value of the “<tt>next</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingSignal #next
--   </pre>
getBindingSignalNext :: MonadIO m => BindingSignal -> m (Maybe BindingSignal)

-- | Set the value of the “<tt>next</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingSignal [ #next <a>:=</a> value ]
--   </pre>
setBindingSignalNext :: MonadIO m => BindingSignal -> Ptr BindingSignal -> m ()

-- | Set the value of the “<tt>next</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #next
--   </pre>
clearBindingSignalNext :: MonadIO m => BindingSignal -> m ()

-- | Get the value of the “<tt>signal_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingSignal #signalName
--   </pre>
getBindingSignalSignalName :: MonadIO m => BindingSignal -> m (Maybe Text)

-- | Set the value of the “<tt>signal_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingSignal [ #signalName <a>:=</a> value ]
--   </pre>
setBindingSignalSignalName :: MonadIO m => BindingSignal -> CString -> m ()

-- | Set the value of the “<tt>signal_name</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #signalName
--   </pre>
clearBindingSignalSignalName :: MonadIO m => BindingSignal -> m ()

-- | Get the value of the “<tt>n_args</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingSignal #nArgs
--   </pre>
getBindingSignalNArgs :: MonadIO m => BindingSignal -> m Word32

-- | Set the value of the “<tt>n_args</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingSignal [ #nArgs <a>:=</a> value ]
--   </pre>
setBindingSignalNArgs :: MonadIO m => BindingSignal -> Word32 -> m ()

-- | Construct a <a>BindingEntry</a> struct initialized to zero.
newZeroBindingEntry :: MonadIO m => m BindingEntry

-- | Get the value of the “<tt>keyval</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingEntry #keyval
--   </pre>
getBindingEntryKeyval :: MonadIO m => BindingEntry -> m Word32

-- | Set the value of the “<tt>keyval</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingEntry [ #keyval <a>:=</a> value ]
--   </pre>
setBindingEntryKeyval :: MonadIO m => BindingEntry -> Word32 -> m ()

-- | Get the value of the “<tt>modifiers</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingEntry #modifiers
--   </pre>
getBindingEntryModifiers :: MonadIO m => BindingEntry -> m [ModifierType]

-- | Set the value of the “<tt>modifiers</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingEntry [ #modifiers <a>:=</a> value ]
--   </pre>
setBindingEntryModifiers :: MonadIO m => BindingEntry -> [ModifierType] -> m ()

-- | Get the value of the “<tt>binding_set</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingEntry #bindingSet
--   </pre>
getBindingEntryBindingSet :: MonadIO m => BindingEntry -> m (Maybe BindingSet)

-- | Set the value of the “<tt>binding_set</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingEntry [ #bindingSet <a>:=</a> value ]
--   </pre>
setBindingEntryBindingSet :: MonadIO m => BindingEntry -> Ptr BindingSet -> m ()

-- | Set the value of the “<tt>binding_set</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #bindingSet
--   </pre>
clearBindingEntryBindingSet :: MonadIO m => BindingEntry -> m ()

-- | Get the value of the “<tt>destroyed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingEntry #destroyed
--   </pre>
getBindingEntryDestroyed :: MonadIO m => BindingEntry -> m Word32

-- | Set the value of the “<tt>destroyed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingEntry [ #destroyed <a>:=</a> value ]
--   </pre>
setBindingEntryDestroyed :: MonadIO m => BindingEntry -> Word32 -> m ()

-- | Get the value of the “<tt>in_emission</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingEntry #inEmission
--   </pre>
getBindingEntryInEmission :: MonadIO m => BindingEntry -> m Word32

-- | Set the value of the “<tt>in_emission</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingEntry [ #inEmission <a>:=</a> value ]
--   </pre>
setBindingEntryInEmission :: MonadIO m => BindingEntry -> Word32 -> m ()

-- | Get the value of the “<tt>marks_unbound</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingEntry #marksUnbound
--   </pre>
getBindingEntryMarksUnbound :: MonadIO m => BindingEntry -> m Word32

-- | Set the value of the “<tt>marks_unbound</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingEntry [ #marksUnbound <a>:=</a> value ]
--   </pre>
setBindingEntryMarksUnbound :: MonadIO m => BindingEntry -> Word32 -> m ()

-- | Get the value of the “<tt>set_next</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingEntry #setNext
--   </pre>
getBindingEntrySetNext :: MonadIO m => BindingEntry -> m (Maybe BindingEntry)

-- | Set the value of the “<tt>set_next</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingEntry [ #setNext <a>:=</a> value ]
--   </pre>
setBindingEntrySetNext :: MonadIO m => BindingEntry -> Ptr BindingEntry -> m ()

-- | Set the value of the “<tt>set_next</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #setNext
--   </pre>
clearBindingEntrySetNext :: MonadIO m => BindingEntry -> m ()

-- | Get the value of the “<tt>hash_next</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingEntry #hashNext
--   </pre>
getBindingEntryHashNext :: MonadIO m => BindingEntry -> m (Maybe BindingEntry)

-- | Set the value of the “<tt>hash_next</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingEntry [ #hashNext <a>:=</a> value ]
--   </pre>
setBindingEntryHashNext :: MonadIO m => BindingEntry -> Ptr BindingEntry -> m ()

-- | Set the value of the “<tt>hash_next</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #hashNext
--   </pre>
clearBindingEntryHashNext :: MonadIO m => BindingEntry -> m ()

-- | Get the value of the “<tt>signals</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingEntry #signals
--   </pre>
getBindingEntrySignals :: MonadIO m => BindingEntry -> m (Maybe BindingSignal)

-- | Set the value of the “<tt>signals</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingEntry [ #signals <a>:=</a> value ]
--   </pre>
setBindingEntrySignals :: MonadIO m => BindingEntry -> Ptr BindingSignal -> m ()

-- | Set the value of the “<tt>signals</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #signals
--   </pre>
clearBindingEntrySignals :: MonadIO m => BindingEntry -> m ()

-- | Parses a signal description from <i><tt>signalDesc</tt></i> and
--   incorporates it into <i><tt>bindingSet</tt></i>.
--   
--   Signal descriptions may either bind a key combination to one or more
--   signals: &gt; &gt; bind "key" { &gt; "signalname" (param, ...) &gt;
--   ... &gt; }
--   
--   Or they may also unbind a key combination: &gt; &gt; unbind "key"
--   
--   Key combinations must be in a format that can be parsed by
--   <a>acceleratorParse</a>.
--   
--   <i>Since: 3.0</i>
bindingEntryAddSignalFromString :: (HasCallStack, MonadIO m) => BindingSet -> Text -> m TokenType

-- | Override or install a new key binding for <i><tt>keyval</tt></i> with
--   <i><tt>modifiers</tt></i> on <i><tt>bindingSet</tt></i>.
bindingEntryAddSignall :: (HasCallStack, MonadIO m) => BindingSet -> Word32 -> [ModifierType] -> Text -> [BindingArg] -> m ()

-- | Remove a binding previously installed via
--   <tt><i>gtk_binding_entry_add_signal()</i></tt> on
--   <i><tt>bindingSet</tt></i>.
bindingEntryRemove :: (HasCallStack, MonadIO m) => BindingSet -> Word32 -> [ModifierType] -> m ()

-- | Install a binding on <i><tt>bindingSet</tt></i> which causes key
--   lookups to be aborted, to prevent bindings from lower priority sets to
--   be activated.
--   
--   <i>Since: 2.12</i>
bindingEntrySkip :: (HasCallStack, MonadIO m) => BindingSet -> Word32 -> [ModifierType] -> m ()

-- | Construct a <a>BindingSet</a> struct initialized to zero.
newZeroBindingSet :: MonadIO m => m BindingSet

-- | Get the value of the “<tt>set_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingSet #setName
--   </pre>
getBindingSetSetName :: MonadIO m => BindingSet -> m (Maybe Text)

-- | Set the value of the “<tt>set_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingSet [ #setName <a>:=</a> value ]
--   </pre>
setBindingSetSetName :: MonadIO m => BindingSet -> CString -> m ()

-- | Set the value of the “<tt>set_name</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #setName
--   </pre>
clearBindingSetSetName :: MonadIO m => BindingSet -> m ()

-- | Get the value of the “<tt>priority</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingSet #priority
--   </pre>
getBindingSetPriority :: MonadIO m => BindingSet -> m Int32

-- | Set the value of the “<tt>priority</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingSet [ #priority <a>:=</a> value ]
--   </pre>
setBindingSetPriority :: MonadIO m => BindingSet -> Int32 -> m ()

-- | Get the value of the “<tt>widget_path_pspecs</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingSet #widgetPathPspecs
--   </pre>
getBindingSetWidgetPathPspecs :: MonadIO m => BindingSet -> m [Ptr ()]

-- | Set the value of the “<tt>widget_path_pspecs</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingSet [ #widgetPathPspecs <a>:=</a> value ]
--   </pre>
setBindingSetWidgetPathPspecs :: MonadIO m => BindingSet -> Ptr (GSList (Ptr ())) -> m ()

-- | Set the value of the “<tt>widget_path_pspecs</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #widgetPathPspecs
--   </pre>
clearBindingSetWidgetPathPspecs :: MonadIO m => BindingSet -> m ()

-- | Get the value of the “<tt>widget_class_pspecs</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingSet #widgetClassPspecs
--   </pre>
getBindingSetWidgetClassPspecs :: MonadIO m => BindingSet -> m [Ptr ()]

-- | Set the value of the “<tt>widget_class_pspecs</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingSet [ #widgetClassPspecs <a>:=</a> value ]
--   </pre>
setBindingSetWidgetClassPspecs :: MonadIO m => BindingSet -> Ptr (GSList (Ptr ())) -> m ()

-- | Set the value of the “<tt>widget_class_pspecs</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #widgetClassPspecs
--   </pre>
clearBindingSetWidgetClassPspecs :: MonadIO m => BindingSet -> m ()

-- | Get the value of the “<tt>class_branch_pspecs</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingSet #classBranchPspecs
--   </pre>
getBindingSetClassBranchPspecs :: MonadIO m => BindingSet -> m [Ptr ()]

-- | Set the value of the “<tt>class_branch_pspecs</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingSet [ #classBranchPspecs <a>:=</a> value ]
--   </pre>
setBindingSetClassBranchPspecs :: MonadIO m => BindingSet -> Ptr (GSList (Ptr ())) -> m ()

-- | Set the value of the “<tt>class_branch_pspecs</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #classBranchPspecs
--   </pre>
clearBindingSetClassBranchPspecs :: MonadIO m => BindingSet -> m ()

-- | Get the value of the “<tt>entries</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingSet #entries
--   </pre>
getBindingSetEntries :: MonadIO m => BindingSet -> m (Maybe BindingEntry)

-- | Set the value of the “<tt>entries</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingSet [ #entries <a>:=</a> value ]
--   </pre>
setBindingSetEntries :: MonadIO m => BindingSet -> Ptr BindingEntry -> m ()

-- | Set the value of the “<tt>entries</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #entries
--   </pre>
clearBindingSetEntries :: MonadIO m => BindingSet -> m ()

-- | Get the value of the “<tt>current</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingSet #current
--   </pre>
getBindingSetCurrent :: MonadIO m => BindingSet -> m (Maybe BindingEntry)

-- | Set the value of the “<tt>current</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingSet [ #current <a>:=</a> value ]
--   </pre>
setBindingSetCurrent :: MonadIO m => BindingSet -> Ptr BindingEntry -> m ()

-- | Set the value of the “<tt>current</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #current
--   </pre>
clearBindingSetCurrent :: MonadIO m => BindingSet -> m ()

-- | Get the value of the “<tt>parsed</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingSet #parsed
--   </pre>
getBindingSetParsed :: MonadIO m => BindingSet -> m Word32

-- | Set the value of the “<tt>parsed</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingSet [ #parsed <a>:=</a> value ]
--   </pre>
setBindingSetParsed :: MonadIO m => BindingSet -> Word32 -> m ()

-- | Find a key binding matching <i><tt>keyval</tt></i> and
--   <i><tt>modifiers</tt></i> within <i><tt>bindingSet</tt></i> and
--   activate the binding on <i><tt>object</tt></i>.
bindingSetActivate :: (HasCallStack, MonadIO m, IsObject a) => BindingSet -> Word32 -> [ModifierType] -> a -> m Bool

-- | Find a binding set by its globally unique name.
--   
--   The <i><tt>setName</tt></i> can either be a name used for
--   <tt><i>gtk_binding_set_new()</i></tt> or the type name of a class used
--   in <tt><i>gtk_binding_set_by_class()</i></tt>.
bindingSetFind :: (HasCallStack, MonadIO m) => Text -> m (Maybe BindingSet)

-- | Construct a <a>Border</a> struct initialized to zero.
newZeroBorder :: MonadIO m => m Border

-- | Get the value of the “<tt>left</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> border #left
--   </pre>
getBorderLeft :: MonadIO m => Border -> m Int16

-- | Set the value of the “<tt>left</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> border [ #left <a>:=</a> value ]
--   </pre>
setBorderLeft :: MonadIO m => Border -> Int16 -> m ()

-- | Get the value of the “<tt>right</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> border #right
--   </pre>
getBorderRight :: MonadIO m => Border -> m Int16

-- | Set the value of the “<tt>right</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> border [ #right <a>:=</a> value ]
--   </pre>
setBorderRight :: MonadIO m => Border -> Int16 -> m ()

-- | Get the value of the “<tt>top</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> border #top
--   </pre>
getBorderTop :: MonadIO m => Border -> m Int16

-- | Set the value of the “<tt>top</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> border [ #top <a>:=</a> value ]
--   </pre>
setBorderTop :: MonadIO m => Border -> Int16 -> m ()

-- | Get the value of the “<tt>bottom</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> border #bottom
--   </pre>
getBorderBottom :: MonadIO m => Border -> m Int16

-- | Set the value of the “<tt>bottom</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> border [ #bottom <a>:=</a> value ]
--   </pre>
setBorderBottom :: MonadIO m => Border -> Int16 -> m ()

-- | Allocates a new <a>Border</a>-struct and initializes its elements to
--   zero.
--   
--   <i>Since: 2.14</i>
borderNew :: (HasCallStack, MonadIO m) => m Border

-- | Copies a <a>Border</a>-struct.
borderCopy :: (HasCallStack, MonadIO m) => Border -> m Border

-- | Frees a <a>Border</a>-struct.
borderFree :: (HasCallStack, MonadIO m) => Border -> m ()

-- | Cast to <a>Scrollable</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toScrollable :: (MonadIO m, IsScrollable o) => o -> m Scrollable

-- | Get the value of the “<tt>hadjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrollable #hadjustment
--   </pre>
getScrollableHadjustment :: (MonadIO m, IsScrollable o) => o -> m Adjustment

-- | Set the value of the “<tt>hadjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrollable [ #hadjustment <a>:=</a> value ]
--   </pre>
setScrollableHadjustment :: (MonadIO m, IsScrollable o, IsAdjustment a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hadjustment</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructScrollableHadjustment :: (IsScrollable o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>hadjustment</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #hadjustment
--   </pre>
clearScrollableHadjustment :: (MonadIO m, IsScrollable o) => o -> m ()

-- | Get the value of the “<tt>hscroll-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrollable #hscrollPolicy
--   </pre>
getScrollableHscrollPolicy :: (MonadIO m, IsScrollable o) => o -> m ScrollablePolicy

-- | Set the value of the “<tt>hscroll-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrollable [ #hscrollPolicy <a>:=</a> value ]
--   </pre>
setScrollableHscrollPolicy :: (MonadIO m, IsScrollable o) => o -> ScrollablePolicy -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hscroll-policy</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrollableHscrollPolicy :: (IsScrollable o, MonadIO m) => ScrollablePolicy -> m (GValueConstruct o)

-- | Get the value of the “<tt>vadjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrollable #vadjustment
--   </pre>
getScrollableVadjustment :: (MonadIO m, IsScrollable o) => o -> m Adjustment

-- | Set the value of the “<tt>vadjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrollable [ #vadjustment <a>:=</a> value ]
--   </pre>
setScrollableVadjustment :: (MonadIO m, IsScrollable o, IsAdjustment a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>vadjustment</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructScrollableVadjustment :: (IsScrollable o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>vadjustment</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #vadjustment
--   </pre>
clearScrollableVadjustment :: (MonadIO m, IsScrollable o) => o -> m ()

-- | Get the value of the “<tt>vscroll-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrollable #vscrollPolicy
--   </pre>
getScrollableVscrollPolicy :: (MonadIO m, IsScrollable o) => o -> m ScrollablePolicy

-- | Set the value of the “<tt>vscroll-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrollable [ #vscrollPolicy <a>:=</a> value ]
--   </pre>
setScrollableVscrollPolicy :: (MonadIO m, IsScrollable o) => o -> ScrollablePolicy -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>vscroll-policy</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrollableVscrollPolicy :: (IsScrollable o, MonadIO m) => ScrollablePolicy -> m (GValueConstruct o)

-- | Returns the size of a non-scrolling border around the outside of the
--   scrollable. An example for this would be treeview headers. GTK+ can
--   use this information to display overlayed graphics, like the overshoot
--   indication, at the right position.
--   
--   <i>Since: 3.16</i>
scrollableGetBorder :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m (Bool, Border)

-- | Retrieves the <a>Adjustment</a> used for horizontal scrolling.
--   
--   <i>Since: 3.0</i>
scrollableGetHadjustment :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m Adjustment

-- | Gets the horizontal <a>ScrollablePolicy</a>.
--   
--   <i>Since: 3.0</i>
scrollableGetHscrollPolicy :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m ScrollablePolicy

-- | Retrieves the <a>Adjustment</a> used for vertical scrolling.
--   
--   <i>Since: 3.0</i>
scrollableGetVadjustment :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m Adjustment

-- | Gets the vertical <a>ScrollablePolicy</a>.
--   
--   <i>Since: 3.0</i>
scrollableGetVscrollPolicy :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m ScrollablePolicy

-- | Sets the horizontal adjustment of the <a>Scrollable</a>.
--   
--   <i>Since: 3.0</i>
scrollableSetHadjustment :: (HasCallStack, MonadIO m, IsScrollable a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Sets the <a>ScrollablePolicy</a> to determine whether horizontal
--   scrolling should start below the minimum width or below the natural
--   width.
--   
--   <i>Since: 3.0</i>
scrollableSetHscrollPolicy :: (HasCallStack, MonadIO m, IsScrollable a) => a -> ScrollablePolicy -> m ()

-- | Sets the vertical adjustment of the <a>Scrollable</a>.
--   
--   <i>Since: 3.0</i>
scrollableSetVadjustment :: (HasCallStack, MonadIO m, IsScrollable a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Sets the <a>ScrollablePolicy</a> to determine whether vertical
--   scrolling should start below the minimum height or below the natural
--   height.
--   
--   <i>Since: 3.0</i>
scrollableSetVscrollPolicy :: (HasCallStack, MonadIO m, IsScrollable a) => a -> ScrollablePolicy -> m ()

-- | Returns the line in the CSS document where this section end. The line
--   number is 0-indexed, so the first line of the document will return 0.
--   This value may change in future invocations of this function if
--   <i><tt>section</tt></i> is not yet parsed completely. This will for
--   example happen in the GtkCssProvider<a>parsingError</a> signal. The
--   end position and line may be identical to the start position and line
--   for sections which failed to parse anything successfully.
--   
--   <i>Since: 3.2</i>
cssSectionGetEndLine :: (HasCallStack, MonadIO m) => CssSection -> m Word32

-- | Returns the offset in bytes from the start of the current line
--   returned via <a>cssSectionGetEndLine</a>. This value may change in
--   future invocations of this function if <i><tt>section</tt></i> is not
--   yet parsed completely. This will for example happen in the
--   GtkCssProvider<a>parsingError</a> signal. The end position and line
--   may be identical to the start position and line for sections which
--   failed to parse anything successfully.
--   
--   <i>Since: 3.2</i>
cssSectionGetEndPosition :: (HasCallStack, MonadIO m) => CssSection -> m Word32

-- | Gets the file that <i><tt>section</tt></i> was parsed from. If no such
--   file exists, for example because the CSS was loaded via
--   <i><tt>gtkCssProviderLoadFromData</tt></i>(), then <a>Nothing</a> is
--   returned.
--   
--   <i>Since: 3.2</i>
cssSectionGetFile :: (HasCallStack, MonadIO m) => CssSection -> m File

-- | Gets the type of information that <i><tt>section</tt></i> describes.
--   
--   <i>Since: 3.2</i>
cssSectionGetSectionType :: (HasCallStack, MonadIO m) => CssSection -> m CssSectionType

-- | Returns the line in the CSS document where this section starts. The
--   line number is 0-indexed, so the first line of the document will
--   return 0.
--   
--   <i>Since: 3.2</i>
cssSectionGetStartLine :: (HasCallStack, MonadIO m) => CssSection -> m Word32

-- | Returns the offset in bytes from the start of the current line
--   returned via <a>cssSectionGetStartLine</a>.
--   
--   <i>Since: 3.2</i>
cssSectionGetStartPosition :: (HasCallStack, MonadIO m) => CssSection -> m Word32

-- | Increments the reference count on <i><tt>section</tt></i>.
--   
--   <i>Since: 3.2</i>
cssSectionRef :: (HasCallStack, MonadIO m) => CssSection -> m CssSection

-- | Decrements the reference count on <i><tt>section</tt></i>, freeing the
--   structure if the reference count reaches 0.
--   
--   <i>Since: 3.2</i>
cssSectionUnref :: (HasCallStack, MonadIO m) => CssSection -> m ()

-- | Construct a <a>FileFilterInfo</a> struct initialized to zero.
newZeroFileFilterInfo :: MonadIO m => m FileFilterInfo

-- | Get the value of the “<tt>contains</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileFilterInfo #contains
--   </pre>
getFileFilterInfoContains :: MonadIO m => FileFilterInfo -> m [FileFilterFlags]

-- | Set the value of the “<tt>contains</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileFilterInfo [ #contains <a>:=</a> value ]
--   </pre>
setFileFilterInfoContains :: MonadIO m => FileFilterInfo -> [FileFilterFlags] -> m ()

-- | Get the value of the “<tt>filename</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileFilterInfo #filename
--   </pre>
getFileFilterInfoFilename :: MonadIO m => FileFilterInfo -> m (Maybe Text)

-- | Set the value of the “<tt>filename</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileFilterInfo [ #filename <a>:=</a> value ]
--   </pre>
setFileFilterInfoFilename :: MonadIO m => FileFilterInfo -> CString -> m ()

-- | Set the value of the “<tt>filename</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #filename
--   </pre>
clearFileFilterInfoFilename :: MonadIO m => FileFilterInfo -> m ()

-- | Get the value of the “<tt>uri</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileFilterInfo #uri
--   </pre>
getFileFilterInfoUri :: MonadIO m => FileFilterInfo -> m (Maybe Text)

-- | Set the value of the “<tt>uri</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileFilterInfo [ #uri <a>:=</a> value ]
--   </pre>
setFileFilterInfoUri :: MonadIO m => FileFilterInfo -> CString -> m ()

-- | Set the value of the “<tt>uri</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #uri
--   </pre>
clearFileFilterInfoUri :: MonadIO m => FileFilterInfo -> m ()

-- | Get the value of the “<tt>display_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileFilterInfo #displayName
--   </pre>
getFileFilterInfoDisplayName :: MonadIO m => FileFilterInfo -> m (Maybe Text)

-- | Set the value of the “<tt>display_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileFilterInfo [ #displayName <a>:=</a> value ]
--   </pre>
setFileFilterInfoDisplayName :: MonadIO m => FileFilterInfo -> CString -> m ()

-- | Set the value of the “<tt>display_name</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #displayName
--   </pre>
clearFileFilterInfoDisplayName :: MonadIO m => FileFilterInfo -> m ()

-- | Get the value of the “<tt>mime_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileFilterInfo #mimeType
--   </pre>
getFileFilterInfoMimeType :: MonadIO m => FileFilterInfo -> m (Maybe Text)

-- | Set the value of the “<tt>mime_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileFilterInfo [ #mimeType <a>:=</a> value ]
--   </pre>
setFileFilterInfoMimeType :: MonadIO m => FileFilterInfo -> CString -> m ()

-- | Set the value of the “<tt>mime_type</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #mimeType
--   </pre>
clearFileFilterInfoMimeType :: MonadIO m => FileFilterInfo -> m ()

-- | Construct a <a>IMContextInfo</a> struct initialized to zero.
newZeroIMContextInfo :: MonadIO m => m IMContextInfo

-- | Get the value of the “<tt>context_id</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iMContextInfo #contextId
--   </pre>
getIMContextInfoContextId :: MonadIO m => IMContextInfo -> m (Maybe Text)

-- | Set the value of the “<tt>context_id</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iMContextInfo [ #contextId <a>:=</a> value ]
--   </pre>
setIMContextInfoContextId :: MonadIO m => IMContextInfo -> CString -> m ()

-- | Set the value of the “<tt>context_id</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #contextId
--   </pre>
clearIMContextInfoContextId :: MonadIO m => IMContextInfo -> m ()

-- | Get the value of the “<tt>context_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iMContextInfo #contextName
--   </pre>
getIMContextInfoContextName :: MonadIO m => IMContextInfo -> m (Maybe Text)

-- | Set the value of the “<tt>context_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iMContextInfo [ #contextName <a>:=</a> value ]
--   </pre>
setIMContextInfoContextName :: MonadIO m => IMContextInfo -> CString -> m ()

-- | Set the value of the “<tt>context_name</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #contextName
--   </pre>
clearIMContextInfoContextName :: MonadIO m => IMContextInfo -> m ()

-- | Get the value of the “<tt>domain</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iMContextInfo #domain
--   </pre>
getIMContextInfoDomain :: MonadIO m => IMContextInfo -> m (Maybe Text)

-- | Set the value of the “<tt>domain</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iMContextInfo [ #domain <a>:=</a> value ]
--   </pre>
setIMContextInfoDomain :: MonadIO m => IMContextInfo -> CString -> m ()

-- | Set the value of the “<tt>domain</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #domain
--   </pre>
clearIMContextInfoDomain :: MonadIO m => IMContextInfo -> m ()

-- | Get the value of the “<tt>domain_dirname</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iMContextInfo #domainDirname
--   </pre>
getIMContextInfoDomainDirname :: MonadIO m => IMContextInfo -> m (Maybe Text)

-- | Set the value of the “<tt>domain_dirname</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iMContextInfo [ #domainDirname <a>:=</a> value ]
--   </pre>
setIMContextInfoDomainDirname :: MonadIO m => IMContextInfo -> CString -> m ()

-- | Set the value of the “<tt>domain_dirname</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #domainDirname
--   </pre>
clearIMContextInfoDomainDirname :: MonadIO m => IMContextInfo -> m ()

-- | Get the value of the “<tt>default_locales</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iMContextInfo #defaultLocales
--   </pre>
getIMContextInfoDefaultLocales :: MonadIO m => IMContextInfo -> m (Maybe Text)

-- | Set the value of the “<tt>default_locales</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iMContextInfo [ #defaultLocales <a>:=</a> value ]
--   </pre>
setIMContextInfoDefaultLocales :: MonadIO m => IMContextInfo -> CString -> m ()

-- | Set the value of the “<tt>default_locales</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #defaultLocales
--   </pre>
clearIMContextInfoDefaultLocales :: MonadIO m => IMContextInfo -> m ()

-- | Creates a new <a>IconSource</a>. A <a>IconSource</a> contains a
--   <a>Pixbuf</a> (or image filename) that serves as the base image for
--   one or more of the icons in a <a>IconSet</a>, along with a
--   specification for which icons in the icon set will be based on that
--   pixbuf or image file. An icon set contains a set of icons that
--   represent “the same” logical concept in different states, different
--   global text directions, and different sizes.
--   
--   So for example a web browser’s “Back to Previous Page” icon might
--   point in a different direction in Hebrew and in English; it might look
--   different when insensitive; and it might change size depending on
--   toolbar mode (small/large icons). So a single icon set would contain
--   all those variants of the icon. <a>IconSet</a> contains a list of
--   <a>IconSource</a> from which it can derive specific icon variants in
--   the set.
--   
--   In the simplest case, <a>IconSet</a> contains one source pixbuf from
--   which it derives all variants. The convenience function
--   <a>iconSetNewFromPixbuf</a> handles this case; if you only have one
--   source pixbuf, just use that function.
--   
--   If you want to use a different base pixbuf for different icon
--   variants, you create multiple icon sources, mark which variants
--   they’ll be used to create, and add them to the icon set with
--   <a>iconSetAddSource</a>.
--   
--   By default, the icon source has all parameters wildcarded. That is,
--   the icon source will be used as the base icon for any desired text
--   direction, widget state, or icon size.
iconSourceNew :: (HasCallStack, MonadIO m) => m IconSource

-- | Creates a copy of <i><tt>source</tt></i>; mostly useful for language
--   bindings.
iconSourceCopy :: (HasCallStack, MonadIO m) => IconSource -> m IconSource

-- | Frees a dynamically-allocated icon source, along with its filename,
--   size, and pixbuf fields if those are not <a>Nothing</a>.
iconSourceFree :: (HasCallStack, MonadIO m) => IconSource -> m ()

-- | Obtains the text direction this icon source applies to. The return
--   value is only useful/meaningful if the text direction is not
--   wildcarded.
iconSourceGetDirection :: (HasCallStack, MonadIO m) => IconSource -> m TextDirection

-- | Gets the value set by <a>iconSourceSetDirectionWildcarded</a>.
iconSourceGetDirectionWildcarded :: (HasCallStack, MonadIO m) => IconSource -> m Bool

-- | Retrieves the source filename, or <a>Nothing</a> if none is set. The
--   filename is not a copy, and should not be modified or expected to
--   persist beyond the lifetime of the icon source.
iconSourceGetFilename :: (HasCallStack, MonadIO m) => IconSource -> m [Char]

-- | Retrieves the source icon name, or <a>Nothing</a> if none is set. The
--   icon_name is not a copy, and should not be modified or expected to
--   persist beyond the lifetime of the icon source.
iconSourceGetIconName :: (HasCallStack, MonadIO m) => IconSource -> m Text

-- | Retrieves the source pixbuf, or <a>Nothing</a> if none is set. In
--   addition, if a filename source is in use, this function in some cases
--   will return the pixbuf from loaded from the filename. This is, for
--   example, true for the GtkIconSource passed to the <a>Style</a>
--   <tt><i>render_icon()</i></tt> virtual function. The reference count on
--   the pixbuf is not incremented.
iconSourceGetPixbuf :: (HasCallStack, MonadIO m) => IconSource -> m Pixbuf

-- | Obtains the icon size this source applies to. The return value is only
--   useful/meaningful if the icon size is not wildcarded.
iconSourceGetSize :: (HasCallStack, MonadIO m) => IconSource -> m Int32

-- | Gets the value set by <a>iconSourceSetSizeWildcarded</a>.
iconSourceGetSizeWildcarded :: (HasCallStack, MonadIO m) => IconSource -> m Bool

-- | Obtains the widget state this icon source applies to. The return value
--   is only useful/meaningful if the widget state is not wildcarded.
iconSourceGetState :: (HasCallStack, MonadIO m) => IconSource -> m StateType

-- | Gets the value set by <a>iconSourceSetStateWildcarded</a>.
iconSourceGetStateWildcarded :: (HasCallStack, MonadIO m) => IconSource -> m Bool

-- | Sets the text direction this icon source is intended to be used with.
--   
--   Setting the text direction on an icon source makes no difference if
--   the text direction is wildcarded. Therefore, you should usually call
--   <a>iconSourceSetDirectionWildcarded</a> to un-wildcard it in addition
--   to calling this function.
iconSourceSetDirection :: (HasCallStack, MonadIO m) => IconSource -> TextDirection -> m ()

-- | If the text direction is wildcarded, this source can be used as the
--   base image for an icon in any <a>TextDirection</a>. If the text
--   direction is not wildcarded, then the text direction the icon source
--   applies to should be set with <a>iconSourceSetDirection</a>, and the
--   icon source will only be used with that text direction.
--   
--   <a>IconSet</a> prefers non-wildcarded sources (exact matches) over
--   wildcarded sources, and will use an exact match when possible.
iconSourceSetDirectionWildcarded :: (HasCallStack, MonadIO m) => IconSource -> Bool -> m ()

-- | Sets the name of an image file to use as a base image when creating
--   icon variants for <a>IconSet</a>. The filename must be absolute.
iconSourceSetFilename :: (HasCallStack, MonadIO m) => IconSource -> [Char] -> m ()

-- | Sets the name of an icon to look up in the current icon theme to use
--   as a base image when creating icon variants for <a>IconSet</a>.
iconSourceSetIconName :: (HasCallStack, MonadIO m) => IconSource -> Maybe Text -> m ()

-- | Sets a pixbuf to use as a base image when creating icon variants for
--   <a>IconSet</a>.
iconSourceSetPixbuf :: (HasCallStack, MonadIO m, IsPixbuf a) => IconSource -> a -> m ()

-- | Sets the icon size this icon source is intended to be used with.
--   
--   Setting the icon size on an icon source makes no difference if the
--   size is wildcarded. Therefore, you should usually call
--   <a>iconSourceSetSizeWildcarded</a> to un-wildcard it in addition to
--   calling this function.
iconSourceSetSize :: (HasCallStack, MonadIO m) => IconSource -> Int32 -> m ()

-- | If the icon size is wildcarded, this source can be used as the base
--   image for an icon of any size. If the size is not wildcarded, then the
--   size the source applies to should be set with <a>iconSourceSetSize</a>
--   and the icon source will only be used with that specific size.
--   
--   <a>IconSet</a> prefers non-wildcarded sources (exact matches) over
--   wildcarded sources, and will use an exact match when possible.
--   
--   <a>IconSet</a> will normally scale wildcarded source images to produce
--   an appropriate icon at a given size, but will not change the size of
--   source images that match exactly.
iconSourceSetSizeWildcarded :: (HasCallStack, MonadIO m) => IconSource -> Bool -> m ()

-- | Sets the widget state this icon source is intended to be used with.
--   
--   Setting the widget state on an icon source makes no difference if the
--   state is wildcarded. Therefore, you should usually call
--   <a>iconSourceSetStateWildcarded</a> to un-wildcard it in addition to
--   calling this function.
iconSourceSetState :: (HasCallStack, MonadIO m) => IconSource -> StateType -> m ()

-- | If the widget state is wildcarded, this source can be used as the base
--   image for an icon in any <a>StateType</a>. If the widget state is not
--   wildcarded, then the state the source applies to should be set with
--   <a>iconSourceSetState</a> and the icon source will only be used with
--   that specific state.
--   
--   <a>IconSet</a> prefers non-wildcarded sources (exact matches) over
--   wildcarded sources, and will use an exact match when possible.
--   
--   <a>IconSet</a> will normally transform wildcarded source images to
--   produce an appropriate icon for a given state, for example lightening
--   an image on prelight, but will not modify source images that match
--   exactly.
iconSourceSetStateWildcarded :: (HasCallStack, MonadIO m) => IconSource -> Bool -> m ()

-- | Construct a <a>MountOperationHandlerIface_</a> struct initialized to
--   zero.
newZeroMountOperationHandlerIface_ :: MonadIO m => m MountOperationHandlerIface_

-- | Get the value of the “<tt>parent_iface</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mountOperationHandlerIface_ #parentIface
--   </pre>
getMountOperationHandlerIface_ParentIface :: MonadIO m => MountOperationHandlerIface_ -> m TypeInterface

-- | Construct a <a>MountOperationHandlerProxyClass_</a> struct initialized
--   to zero.
newZeroMountOperationHandlerProxyClass_ :: MonadIO m => m MountOperationHandlerProxyClass_

-- | Construct a <a>MountOperationHandlerProxy_</a> struct initialized to
--   zero.
newZeroMountOperationHandlerProxy_ :: MonadIO m => m MountOperationHandlerProxy_

-- | Construct a <a>MountOperationHandlerSkeletonClass_</a> struct
--   initialized to zero.
newZeroMountOperationHandlerSkeletonClass_ :: MonadIO m => m MountOperationHandlerSkeletonClass_

-- | Construct a <a>MountOperationHandlerSkeleton_</a> struct initialized
--   to zero.
newZeroMountOperationHandlerSkeleton_ :: MonadIO m => m MountOperationHandlerSkeleton_

-- | Construct a <a>PadActionEntry</a> struct initialized to zero.
newZeroPadActionEntry :: MonadIO m => m PadActionEntry

-- | Get the value of the “<tt>type</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> padActionEntry #type
--   </pre>
getPadActionEntryType :: MonadIO m => PadActionEntry -> m PadActionType

-- | Set the value of the “<tt>type</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> padActionEntry [ #type <a>:=</a> value ]
--   </pre>
setPadActionEntryType :: MonadIO m => PadActionEntry -> PadActionType -> m ()

-- | Get the value of the “<tt>index</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> padActionEntry #index
--   </pre>
getPadActionEntryIndex :: MonadIO m => PadActionEntry -> m Int32

-- | Set the value of the “<tt>index</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> padActionEntry [ #index <a>:=</a> value ]
--   </pre>
setPadActionEntryIndex :: MonadIO m => PadActionEntry -> Int32 -> m ()

-- | Get the value of the “<tt>mode</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> padActionEntry #mode
--   </pre>
getPadActionEntryMode :: MonadIO m => PadActionEntry -> m Int32

-- | Set the value of the “<tt>mode</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> padActionEntry [ #mode <a>:=</a> value ]
--   </pre>
setPadActionEntryMode :: MonadIO m => PadActionEntry -> Int32 -> m ()

-- | Get the value of the “<tt>label</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> padActionEntry #label
--   </pre>
getPadActionEntryLabel :: MonadIO m => PadActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>label</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> padActionEntry [ #label <a>:=</a> value ]
--   </pre>
setPadActionEntryLabel :: MonadIO m => PadActionEntry -> CString -> m ()

-- | Set the value of the “<tt>label</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #label
--   </pre>
clearPadActionEntryLabel :: MonadIO m => PadActionEntry -> m ()

-- | Get the value of the “<tt>action_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> padActionEntry #actionName
--   </pre>
getPadActionEntryActionName :: MonadIO m => PadActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>action_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> padActionEntry [ #actionName <a>:=</a> value ]
--   </pre>
setPadActionEntryActionName :: MonadIO m => PadActionEntry -> CString -> m ()

-- | Set the value of the “<tt>action_name</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #actionName
--   </pre>
clearPadActionEntryActionName :: MonadIO m => PadActionEntry -> m ()

-- | Construct a <a>PageRange</a> struct initialized to zero.
newZeroPageRange :: MonadIO m => m PageRange

-- | Get the value of the “<tt>start</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> pageRange #start
--   </pre>
getPageRangeStart :: MonadIO m => PageRange -> m Int32

-- | Set the value of the “<tt>start</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> pageRange [ #start <a>:=</a> value ]
--   </pre>
setPageRangeStart :: MonadIO m => PageRange -> Int32 -> m ()

-- | Get the value of the “<tt>end</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> pageRange #end
--   </pre>
getPageRangeEnd :: MonadIO m => PageRange -> m Int32

-- | Set the value of the “<tt>end</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> pageRange [ #end <a>:=</a> value ]
--   </pre>
setPageRangeEnd :: MonadIO m => PageRange -> Int32 -> m ()

-- | Creates a new <a>PaperSize</a> object by parsing a <a>PWG
--   5101.1-2002</a> paper name.
--   
--   If <i><tt>name</tt></i> is <a>Nothing</a>, the default paper size is
--   returned, see <a>paperSizeGetDefault</a>.
--   
--   <i>Since: 2.10</i>
paperSizeNew :: (HasCallStack, MonadIO m) => Maybe Text -> m PaperSize

-- | Creates a new <a>PaperSize</a> object with the given parameters.
--   
--   <i>Since: 2.10</i>
paperSizeNewCustom :: (HasCallStack, MonadIO m) => Text -> Text -> Double -> Double -> Unit -> m PaperSize

-- | Deserialize a paper size from an a{sv} variant in the format produced
--   by <a>paperSizeToGvariant</a>.
--   
--   <i>Since: 3.22</i>
paperSizeNewFromGvariant :: (HasCallStack, MonadIO m) => GVariant -> m PaperSize

-- | Creates a new <a>PaperSize</a> object by using IPP information.
--   
--   If <i><tt>ippName</tt></i> is not a recognized paper name,
--   <i><tt>width</tt></i> and <i><tt>height</tt></i> are used to construct
--   a custom <a>PaperSize</a> object.
--   
--   <i>Since: 3.16</i>
paperSizeNewFromIpp :: (HasCallStack, MonadIO m) => Text -> Double -> Double -> m PaperSize

-- | Reads a paper size from the group <i><tt>groupName</tt></i> in the key
--   file <i><tt>keyFile</tt></i>.
--   
--   <i>Since: 2.12</i>
paperSizeNewFromKeyFile :: (HasCallStack, MonadIO m) => KeyFile -> Maybe Text -> m PaperSize

-- | Creates a new <a>PaperSize</a> object by using PPD information.
--   
--   If <i><tt>ppdName</tt></i> is not a recognized PPD paper name,
--   <i><tt>ppdDisplayName</tt></i>, <i><tt>width</tt></i> and
--   <i><tt>height</tt></i> are used to construct a custom <a>PaperSize</a>
--   object.
--   
--   <i>Since: 2.10</i>
paperSizeNewFromPpd :: (HasCallStack, MonadIO m) => Text -> Text -> Double -> Double -> m PaperSize

-- | Copies an existing <a>PaperSize</a>.
--   
--   <i>Since: 2.10</i>
paperSizeCopy :: (HasCallStack, MonadIO m) => PaperSize -> m PaperSize

-- | Free the given <a>PaperSize</a> object.
--   
--   <i>Since: 2.10</i>
paperSizeFree :: (HasCallStack, MonadIO m) => PaperSize -> m ()

-- | Gets the default bottom margin for the <a>PaperSize</a>.
--   
--   <i>Since: 2.10</i>
paperSizeGetDefaultBottomMargin :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Gets the default left margin for the <a>PaperSize</a>.
--   
--   <i>Since: 2.10</i>
paperSizeGetDefaultLeftMargin :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Gets the default right margin for the <a>PaperSize</a>.
--   
--   <i>Since: 2.10</i>
paperSizeGetDefaultRightMargin :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Gets the default top margin for the <a>PaperSize</a>.
--   
--   <i>Since: 2.10</i>
paperSizeGetDefaultTopMargin :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Gets the human-readable name of the <a>PaperSize</a>.
--   
--   <i>Since: 2.10</i>
paperSizeGetDisplayName :: (HasCallStack, MonadIO m) => PaperSize -> m Text

-- | Gets the paper height of the <a>PaperSize</a>, in units of
--   <i><tt>unit</tt></i>.
--   
--   <i>Since: 2.10</i>
paperSizeGetHeight :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Gets the name of the <a>PaperSize</a>.
--   
--   <i>Since: 2.10</i>
paperSizeGetName :: (HasCallStack, MonadIO m) => PaperSize -> m Text

-- | Gets the PPD name of the <a>PaperSize</a>, which may be
--   <a>Nothing</a>.
--   
--   <i>Since: 2.10</i>
paperSizeGetPpdName :: (HasCallStack, MonadIO m) => PaperSize -> m Text

-- | Gets the paper width of the <a>PaperSize</a>, in units of
--   <i><tt>unit</tt></i>.
--   
--   <i>Since: 2.10</i>
paperSizeGetWidth :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Returns <a>True</a> if <i><tt>size</tt></i> is not a standard paper
--   size.
paperSizeIsCustom :: (HasCallStack, MonadIO m) => PaperSize -> m Bool

-- | Compares two <a>PaperSize</a> objects.
--   
--   <i>Since: 2.10</i>
paperSizeIsEqual :: (HasCallStack, MonadIO m) => PaperSize -> PaperSize -> m Bool

-- | Returns <a>True</a> if <i><tt>size</tt></i> is an IPP standard paper
--   size.
paperSizeIsIpp :: (HasCallStack, MonadIO m) => PaperSize -> m Bool

-- | Changes the dimensions of a <i><tt>size</tt></i> to
--   <i><tt>width</tt></i> x <i><tt>height</tt></i>.
--   
--   <i>Since: 2.10</i>
paperSizeSetSize :: (HasCallStack, MonadIO m) => PaperSize -> Double -> Double -> Unit -> m ()

-- | Serialize a paper size to an a{sv} variant.
--   
--   <i>Since: 3.22</i>
paperSizeToGvariant :: (HasCallStack, MonadIO m) => PaperSize -> m GVariant

-- | This function adds the paper size from <i><tt>size</tt></i> to
--   <i><tt>keyFile</tt></i>.
--   
--   <i>Since: 2.12</i>
paperSizeToKeyFile :: (HasCallStack, MonadIO m) => PaperSize -> KeyFile -> Text -> m ()

-- | Creates a list of known paper sizes.
--   
--   <i>Since: 2.12</i>
paperSizeGetPaperSizes :: (HasCallStack, MonadIO m) => Bool -> m [PaperSize]

-- | Cast to <a>PageSetup</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPageSetup :: (MonadIO m, IsPageSetup o) => o -> m PageSetup

-- | Creates a new <a>PageSetup</a>.
--   
--   <i>Since: 2.10</i>
pageSetupNew :: (HasCallStack, MonadIO m) => m PageSetup

-- | Reads the page setup from the file <i><tt>fileName</tt></i>. Returns a
--   new <a>PageSetup</a> object with the restored page setup, or
--   <a>Nothing</a> if an error occurred. See <a>pageSetupToFile</a>.
--   
--   <i>Since: 2.12</i>
pageSetupNewFromFile :: (HasCallStack, MonadIO m) => [Char] -> m PageSetup

-- | Desrialize a page setup from an a{sv} variant in the format produced
--   by <a>pageSetupToGvariant</a>.
--   
--   <i>Since: 3.22</i>
pageSetupNewFromGvariant :: (HasCallStack, MonadIO m) => GVariant -> m PageSetup

-- | Reads the page setup from the group <i><tt>groupName</tt></i> in the
--   key file <i><tt>keyFile</tt></i>. Returns a new <a>PageSetup</a>
--   object with the restored page setup, or <a>Nothing</a> if an error
--   occurred.
--   
--   <i>Since: 2.12</i>
pageSetupNewFromKeyFile :: (HasCallStack, MonadIO m) => KeyFile -> Maybe Text -> m PageSetup

-- | Copies a <a>PageSetup</a>.
--   
--   <i>Since: 2.10</i>
pageSetupCopy :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> m PageSetup

-- | Gets the bottom margin in units of <i><tt>unit</tt></i>.
--   
--   <i>Since: 2.10</i>
pageSetupGetBottomMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Gets the left margin in units of <i><tt>unit</tt></i>.
--   
--   <i>Since: 2.10</i>
pageSetupGetLeftMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Gets the page orientation of the <a>PageSetup</a>.
--   
--   <i>Since: 2.10</i>
pageSetupGetOrientation :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> m PageOrientation

-- | Returns the page height in units of <i><tt>unit</tt></i>.
--   
--   Note that this function takes orientation and margins into
--   consideration. See <a>pageSetupGetPaperHeight</a>.
--   
--   <i>Since: 2.10</i>
pageSetupGetPageHeight :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Returns the page width in units of <i><tt>unit</tt></i>.
--   
--   Note that this function takes orientation and margins into
--   consideration. See <a>pageSetupGetPaperWidth</a>.
--   
--   <i>Since: 2.10</i>
pageSetupGetPageWidth :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Returns the paper height in units of <i><tt>unit</tt></i>.
--   
--   Note that this function takes orientation, but not margins into
--   consideration. See <a>pageSetupGetPageHeight</a>.
--   
--   <i>Since: 2.10</i>
pageSetupGetPaperHeight :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Gets the paper size of the <a>PageSetup</a>.
--   
--   <i>Since: 2.10</i>
pageSetupGetPaperSize :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> m PaperSize

-- | Returns the paper width in units of <i><tt>unit</tt></i>.
--   
--   Note that this function takes orientation, but not margins into
--   consideration. See <a>pageSetupGetPageWidth</a>.
--   
--   <i>Since: 2.10</i>
pageSetupGetPaperWidth :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Gets the right margin in units of <i><tt>unit</tt></i>.
--   
--   <i>Since: 2.10</i>
pageSetupGetRightMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Gets the top margin in units of <i><tt>unit</tt></i>.
--   
--   <i>Since: 2.10</i>
pageSetupGetTopMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Reads the page setup from the file <i><tt>fileName</tt></i>. See
--   <a>pageSetupToFile</a>.
--   
--   <i>Since: 2.14</i>
pageSetupLoadFile :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> [Char] -> m ()

-- | Reads the page setup from the group <i><tt>groupName</tt></i> in the
--   key file <i><tt>keyFile</tt></i>.
--   
--   <i>Since: 2.14</i>
pageSetupLoadKeyFile :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> KeyFile -> Maybe Text -> m ()

-- | Sets the bottom margin of the <a>PageSetup</a>.
--   
--   <i>Since: 2.10</i>
pageSetupSetBottomMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Double -> Unit -> m ()

-- | Sets the left margin of the <a>PageSetup</a>.
--   
--   <i>Since: 2.10</i>
pageSetupSetLeftMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Double -> Unit -> m ()

-- | Sets the page orientation of the <a>PageSetup</a>.
--   
--   <i>Since: 2.10</i>
pageSetupSetOrientation :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> PageOrientation -> m ()

-- | Sets the paper size of the <a>PageSetup</a> without changing the
--   margins. See <a>pageSetupSetPaperSizeAndDefaultMargins</a>.
--   
--   <i>Since: 2.10</i>
pageSetupSetPaperSize :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> PaperSize -> m ()

-- | Sets the paper size of the <a>PageSetup</a> and modifies the margins
--   according to the new paper size.
--   
--   <i>Since: 2.10</i>
pageSetupSetPaperSizeAndDefaultMargins :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> PaperSize -> m ()

-- | Sets the right margin of the <a>PageSetup</a>.
--   
--   <i>Since: 2.10</i>
pageSetupSetRightMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Double -> Unit -> m ()

-- | Sets the top margin of the <a>PageSetup</a>.
--   
--   <i>Since: 2.10</i>
pageSetupSetTopMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Double -> Unit -> m ()

-- | This function saves the information from <i><tt>setup</tt></i> to
--   <i><tt>fileName</tt></i>.
--   
--   <i>Since: 2.12</i>
pageSetupToFile :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> [Char] -> m ()

-- | Serialize page setup to an a{sv} variant.
--   
--   <i>Since: 3.22</i>
pageSetupToGvariant :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> m GVariant

-- | This function adds the page setup from <i><tt>setup</tt></i> to
--   <i><tt>keyFile</tt></i>.
--   
--   <i>Since: 2.12</i>
pageSetupToKeyFile :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> KeyFile -> Maybe Text -> m ()

-- | Cast to <a>PrintContext</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPrintContext :: (MonadIO m, IsPrintContext o) => o -> m PrintContext

-- | Creates a new <a>Context</a> that can be used with the
--   <a>PrintContext</a>.
--   
--   <i>Since: 2.10</i>
printContextCreatePangoContext :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Context

-- | Creates a new <a>Layout</a> that is suitable for use with the
--   <a>PrintContext</a>.
--   
--   <i>Since: 2.10</i>
printContextCreatePangoLayout :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Layout

-- | Obtains the horizontal resolution of the <a>PrintContext</a>, in dots
--   per inch.
--   
--   <i>Since: 2.10</i>
printContextGetDpiX :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Double

-- | Obtains the vertical resolution of the <a>PrintContext</a>, in dots
--   per inch.
--   
--   <i>Since: 2.10</i>
printContextGetDpiY :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Double

-- | Obtains the hardware printer margins of the <a>PrintContext</a>, in
--   units.
--   
--   <i>Since: 2.20</i>
printContextGetHardMargins :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m (Bool, Double, Double, Double, Double)

-- | Obtains the height of the <a>PrintContext</a>, in pixels.
--   
--   <i>Since: 2.10</i>
printContextGetHeight :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Double

-- | Obtains the <a>PageSetup</a> that determines the page dimensions of
--   the <a>PrintContext</a>.
--   
--   <i>Since: 2.10</i>
printContextGetPageSetup :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m PageSetup

-- | Returns a <a>FontMap</a> that is suitable for use with the
--   <a>PrintContext</a>.
--   
--   <i>Since: 2.10</i>
printContextGetPangoFontmap :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m FontMap

-- | Obtains the width of the <a>PrintContext</a>, in pixels.
--   
--   <i>Since: 2.10</i>
printContextGetWidth :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Double

-- | Cast to <a>PrintOperationPreview</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toPrintOperationPreview :: (MonadIO m, IsPrintOperationPreview o) => o -> m PrintOperationPreview

-- | Connect a signal handler for the <a>gotPageSize</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> printOperationPreview #gotPageSize callback
--   </pre>
onPrintOperationPreviewGotPageSize :: (IsPrintOperationPreview a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewGotPageSizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>gotPageSize</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> printOperationPreview #gotPageSize callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationPreviewGotPageSize :: (IsPrintOperationPreview a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewGotPageSizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>ready</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> printOperationPreview #ready callback
--   </pre>
onPrintOperationPreviewReady :: (IsPrintOperationPreview a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewReadyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>ready</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> printOperationPreview #ready callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationPreviewReady :: (IsPrintOperationPreview a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewReadyCallback) -> m SignalHandlerId

-- | Construct a <a>RadioActionEntry</a> struct initialized to zero.
newZeroRadioActionEntry :: MonadIO m => m RadioActionEntry

-- | Get the value of the “<tt>name</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> radioActionEntry #name
--   </pre>
getRadioActionEntryName :: MonadIO m => RadioActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>name</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> radioActionEntry [ #name <a>:=</a> value ]
--   </pre>
setRadioActionEntryName :: MonadIO m => RadioActionEntry -> CString -> m ()

-- | Set the value of the “<tt>name</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #name
--   </pre>
clearRadioActionEntryName :: MonadIO m => RadioActionEntry -> m ()

-- | Get the value of the “<tt>stock_id</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> radioActionEntry #stockId
--   </pre>
getRadioActionEntryStockId :: MonadIO m => RadioActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>stock_id</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> radioActionEntry [ #stockId <a>:=</a> value ]
--   </pre>
setRadioActionEntryStockId :: MonadIO m => RadioActionEntry -> CString -> m ()

-- | Set the value of the “<tt>stock_id</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #stockId
--   </pre>
clearRadioActionEntryStockId :: MonadIO m => RadioActionEntry -> m ()

-- | Get the value of the “<tt>label</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> radioActionEntry #label
--   </pre>
getRadioActionEntryLabel :: MonadIO m => RadioActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>label</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> radioActionEntry [ #label <a>:=</a> value ]
--   </pre>
setRadioActionEntryLabel :: MonadIO m => RadioActionEntry -> CString -> m ()

-- | Set the value of the “<tt>label</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #label
--   </pre>
clearRadioActionEntryLabel :: MonadIO m => RadioActionEntry -> m ()

-- | Get the value of the “<tt>accelerator</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> radioActionEntry #accelerator
--   </pre>
getRadioActionEntryAccelerator :: MonadIO m => RadioActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>accelerator</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> radioActionEntry [ #accelerator <a>:=</a> value ]
--   </pre>
setRadioActionEntryAccelerator :: MonadIO m => RadioActionEntry -> CString -> m ()

-- | Set the value of the “<tt>accelerator</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #accelerator
--   </pre>
clearRadioActionEntryAccelerator :: MonadIO m => RadioActionEntry -> m ()

-- | Get the value of the “<tt>tooltip</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> radioActionEntry #tooltip
--   </pre>
getRadioActionEntryTooltip :: MonadIO m => RadioActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>tooltip</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> radioActionEntry [ #tooltip <a>:=</a> value ]
--   </pre>
setRadioActionEntryTooltip :: MonadIO m => RadioActionEntry -> CString -> m ()

-- | Set the value of the “<tt>tooltip</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #tooltip
--   </pre>
clearRadioActionEntryTooltip :: MonadIO m => RadioActionEntry -> m ()

-- | Get the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> radioActionEntry #value
--   </pre>
getRadioActionEntryValue :: MonadIO m => RadioActionEntry -> m Int32

-- | Set the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> radioActionEntry [ #value <a>:=</a> value ]
--   </pre>
setRadioActionEntryValue :: MonadIO m => RadioActionEntry -> Int32 -> m ()

-- | Construct a <a>RcProperty</a> struct initialized to zero.
newZeroRcProperty :: MonadIO m => m RcProperty

-- | Get the value of the “<tt>type_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> rcProperty #typeName
--   </pre>
getRcPropertyTypeName :: MonadIO m => RcProperty -> m Word32

-- | Set the value of the “<tt>type_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> rcProperty [ #typeName <a>:=</a> value ]
--   </pre>
setRcPropertyTypeName :: MonadIO m => RcProperty -> Word32 -> m ()

-- | Get the value of the “<tt>property_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> rcProperty #propertyName
--   </pre>
getRcPropertyPropertyName :: MonadIO m => RcProperty -> m Word32

-- | Set the value of the “<tt>property_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> rcProperty [ #propertyName <a>:=</a> value ]
--   </pre>
setRcPropertyPropertyName :: MonadIO m => RcProperty -> Word32 -> m ()

-- | Get the value of the “<tt>origin</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> rcProperty #origin
--   </pre>
getRcPropertyOrigin :: MonadIO m => RcProperty -> m (Maybe Text)

-- | Set the value of the “<tt>origin</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> rcProperty [ #origin <a>:=</a> value ]
--   </pre>
setRcPropertyOrigin :: MonadIO m => RcProperty -> CString -> m ()

-- | Set the value of the “<tt>origin</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #origin
--   </pre>
clearRcPropertyOrigin :: MonadIO m => RcProperty -> m ()

-- | Get the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> rcProperty #value
--   </pre>
getRcPropertyValue :: MonadIO m => RcProperty -> m (Maybe GValue)

-- | Set the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> rcProperty [ #value <a>:=</a> value ]
--   </pre>
setRcPropertyValue :: MonadIO m => RcProperty -> Ptr GValue -> m ()

-- | Set the value of the “<tt>value</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #value
--   </pre>
clearRcPropertyValue :: MonadIO m => RcProperty -> m ()

-- | A <a>RcPropertyParser</a> for use with
--   <a>settingsInstallPropertyParser</a> or
--   <tt><i>gtk_widget_class_install_style_property_parser()</i></tt> which
--   parses borders in the form <tt>"{ left, right, top, bottom }"</tt> for
--   integers left, right, top and bottom.
rcPropertyParseBorder :: (HasCallStack, MonadIO m) => GParamSpec -> String -> GValue -> m Bool

-- | A <a>RcPropertyParser</a> for use with
--   <a>settingsInstallPropertyParser</a> or
--   <tt><i>gtk_widget_class_install_style_property_parser()</i></tt> which
--   parses a color given either by its name or in the form <tt>{ red,
--   green, blue }</tt> where red, green and blue are integers between 0
--   and 65535 or floating-point numbers between 0 and 1.
rcPropertyParseColor :: (HasCallStack, MonadIO m) => GParamSpec -> String -> GValue -> m Bool

-- | A <a>RcPropertyParser</a> for use with
--   <a>settingsInstallPropertyParser</a> or
--   <tt><i>gtk_widget_class_install_style_property_parser()</i></tt> which
--   parses a single enumeration value.
--   
--   The enumeration value can be specified by its name, its nickname or
--   its numeric value. For consistency with flags parsing, the value may
--   be surrounded by parentheses.
rcPropertyParseEnum :: (HasCallStack, MonadIO m) => GParamSpec -> String -> GValue -> m Bool

-- | A <a>RcPropertyParser</a> for use with
--   <a>settingsInstallPropertyParser</a> or
--   <tt><i>gtk_widget_class_install_style_property_parser()</i></tt> which
--   parses flags.
--   
--   Flags can be specified by their name, their nickname or numerically.
--   Multiple flags can be specified in the form <tt>"( flag1 | flag2 | ...
--   )"</tt>.
rcPropertyParseFlags :: (HasCallStack, MonadIO m) => GParamSpec -> String -> GValue -> m Bool

-- | A <a>RcPropertyParser</a> for use with
--   <a>settingsInstallPropertyParser</a> or
--   <tt><i>gtk_widget_class_install_style_property_parser()</i></tt> which
--   parses a requisition in the form <tt>"{ width, height }"</tt> for
--   integers <tt><i>width</i></tt> and <tt><i>height</i></tt>.
rcPropertyParseRequisition :: (HasCallStack, MonadIO m) => GParamSpec -> String -> GValue -> m Bool

-- | Construct a <a>RecentData</a> struct initialized to zero.
newZeroRecentData :: MonadIO m => m RecentData

-- | Get the value of the “<tt>display_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentData #displayName
--   </pre>
getRecentDataDisplayName :: MonadIO m => RecentData -> m (Maybe Text)

-- | Set the value of the “<tt>display_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentData [ #displayName <a>:=</a> value ]
--   </pre>
setRecentDataDisplayName :: MonadIO m => RecentData -> CString -> m ()

-- | Set the value of the “<tt>display_name</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #displayName
--   </pre>
clearRecentDataDisplayName :: MonadIO m => RecentData -> m ()

-- | Get the value of the “<tt>description</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentData #description
--   </pre>
getRecentDataDescription :: MonadIO m => RecentData -> m (Maybe Text)

-- | Set the value of the “<tt>description</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentData [ #description <a>:=</a> value ]
--   </pre>
setRecentDataDescription :: MonadIO m => RecentData -> CString -> m ()

-- | Set the value of the “<tt>description</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #description
--   </pre>
clearRecentDataDescription :: MonadIO m => RecentData -> m ()

-- | Get the value of the “<tt>mime_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentData #mimeType
--   </pre>
getRecentDataMimeType :: MonadIO m => RecentData -> m (Maybe Text)

-- | Set the value of the “<tt>mime_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentData [ #mimeType <a>:=</a> value ]
--   </pre>
setRecentDataMimeType :: MonadIO m => RecentData -> CString -> m ()

-- | Set the value of the “<tt>mime_type</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #mimeType
--   </pre>
clearRecentDataMimeType :: MonadIO m => RecentData -> m ()

-- | Get the value of the “<tt>app_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentData #appName
--   </pre>
getRecentDataAppName :: MonadIO m => RecentData -> m (Maybe Text)

-- | Set the value of the “<tt>app_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentData [ #appName <a>:=</a> value ]
--   </pre>
setRecentDataAppName :: MonadIO m => RecentData -> CString -> m ()

-- | Set the value of the “<tt>app_name</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #appName
--   </pre>
clearRecentDataAppName :: MonadIO m => RecentData -> m ()

-- | Get the value of the “<tt>app_exec</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentData #appExec
--   </pre>
getRecentDataAppExec :: MonadIO m => RecentData -> m (Maybe Text)

-- | Set the value of the “<tt>app_exec</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentData [ #appExec <a>:=</a> value ]
--   </pre>
setRecentDataAppExec :: MonadIO m => RecentData -> CString -> m ()

-- | Set the value of the “<tt>app_exec</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #appExec
--   </pre>
clearRecentDataAppExec :: MonadIO m => RecentData -> m ()

-- | Get the value of the “<tt>groups</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentData #groups
--   </pre>
getRecentDataGroups :: MonadIO m => RecentData -> m (Maybe [Text])

-- | Set the value of the “<tt>groups</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentData [ #groups <a>:=</a> value ]
--   </pre>
setRecentDataGroups :: MonadIO m => RecentData -> Ptr CString -> m ()

-- | Set the value of the “<tt>groups</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #groups
--   </pre>
clearRecentDataGroups :: MonadIO m => RecentData -> m ()

-- | Get the value of the “<tt>is_private</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentData #isPrivate
--   </pre>
getRecentDataIsPrivate :: MonadIO m => RecentData -> m Bool

-- | Set the value of the “<tt>is_private</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentData [ #isPrivate <a>:=</a> value ]
--   </pre>
setRecentDataIsPrivate :: MonadIO m => RecentData -> Bool -> m ()

-- | Construct a <a>RecentFilterInfo</a> struct initialized to zero.
newZeroRecentFilterInfo :: MonadIO m => m RecentFilterInfo

-- | Get the value of the “<tt>contains</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentFilterInfo #contains
--   </pre>
getRecentFilterInfoContains :: MonadIO m => RecentFilterInfo -> m [RecentFilterFlags]

-- | Set the value of the “<tt>contains</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentFilterInfo [ #contains <a>:=</a> value ]
--   </pre>
setRecentFilterInfoContains :: MonadIO m => RecentFilterInfo -> [RecentFilterFlags] -> m ()

-- | Get the value of the “<tt>uri</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentFilterInfo #uri
--   </pre>
getRecentFilterInfoUri :: MonadIO m => RecentFilterInfo -> m (Maybe Text)

-- | Set the value of the “<tt>uri</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentFilterInfo [ #uri <a>:=</a> value ]
--   </pre>
setRecentFilterInfoUri :: MonadIO m => RecentFilterInfo -> CString -> m ()

-- | Set the value of the “<tt>uri</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #uri
--   </pre>
clearRecentFilterInfoUri :: MonadIO m => RecentFilterInfo -> m ()

-- | Get the value of the “<tt>display_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentFilterInfo #displayName
--   </pre>
getRecentFilterInfoDisplayName :: MonadIO m => RecentFilterInfo -> m (Maybe Text)

-- | Set the value of the “<tt>display_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentFilterInfo [ #displayName <a>:=</a> value ]
--   </pre>
setRecentFilterInfoDisplayName :: MonadIO m => RecentFilterInfo -> CString -> m ()

-- | Set the value of the “<tt>display_name</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #displayName
--   </pre>
clearRecentFilterInfoDisplayName :: MonadIO m => RecentFilterInfo -> m ()

-- | Get the value of the “<tt>mime_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentFilterInfo #mimeType
--   </pre>
getRecentFilterInfoMimeType :: MonadIO m => RecentFilterInfo -> m (Maybe Text)

-- | Set the value of the “<tt>mime_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentFilterInfo [ #mimeType <a>:=</a> value ]
--   </pre>
setRecentFilterInfoMimeType :: MonadIO m => RecentFilterInfo -> CString -> m ()

-- | Set the value of the “<tt>mime_type</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #mimeType
--   </pre>
clearRecentFilterInfoMimeType :: MonadIO m => RecentFilterInfo -> m ()

-- | Get the value of the “<tt>applications</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentFilterInfo #applications
--   </pre>
getRecentFilterInfoApplications :: MonadIO m => RecentFilterInfo -> m (Maybe [Text])

-- | Set the value of the “<tt>applications</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentFilterInfo [ #applications <a>:=</a> value ]
--   </pre>
setRecentFilterInfoApplications :: MonadIO m => RecentFilterInfo -> Ptr CString -> m ()

-- | Set the value of the “<tt>applications</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #applications
--   </pre>
clearRecentFilterInfoApplications :: MonadIO m => RecentFilterInfo -> m ()

-- | Get the value of the “<tt>groups</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentFilterInfo #groups
--   </pre>
getRecentFilterInfoGroups :: MonadIO m => RecentFilterInfo -> m (Maybe [Text])

-- | Set the value of the “<tt>groups</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentFilterInfo [ #groups <a>:=</a> value ]
--   </pre>
setRecentFilterInfoGroups :: MonadIO m => RecentFilterInfo -> Ptr CString -> m ()

-- | Set the value of the “<tt>groups</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #groups
--   </pre>
clearRecentFilterInfoGroups :: MonadIO m => RecentFilterInfo -> m ()

-- | Get the value of the “<tt>age</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentFilterInfo #age
--   </pre>
getRecentFilterInfoAge :: MonadIO m => RecentFilterInfo -> m Int32

-- | Set the value of the “<tt>age</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentFilterInfo [ #age <a>:=</a> value ]
--   </pre>
setRecentFilterInfoAge :: MonadIO m => RecentFilterInfo -> Int32 -> m ()

-- | Creates a <a>AppInfo</a> for the specified <a>RecentInfo</a>
recentInfoCreateAppInfo :: (HasCallStack, MonadIO m) => RecentInfo -> Maybe Text -> m (Maybe AppInfo)

-- | Checks whether the resource pointed by <i><tt>info</tt></i> still
--   exists. At the moment this check is done only on resources pointing to
--   local files.
--   
--   <i>Since: 2.10</i>
recentInfoExists :: (HasCallStack, MonadIO m) => RecentInfo -> m Bool

-- | Gets the timestamp (seconds from system’s Epoch) when the resource was
--   added to the recently used resources list.
--   
--   <i>Since: 2.10</i>
recentInfoGetAdded :: (HasCallStack, MonadIO m) => RecentInfo -> m CTime

-- | Gets the number of days elapsed since the last update of the resource
--   pointed by <i><tt>info</tt></i>.
--   
--   <i>Since: 2.10</i>
recentInfoGetAge :: (HasCallStack, MonadIO m) => RecentInfo -> m Int32

-- | Gets the data regarding the application that has registered the
--   resource pointed by <i><tt>info</tt></i>.
--   
--   If the command line contains any escape characters defined inside the
--   storage specification, they will be expanded.
--   
--   <i>Since: 2.10</i>
recentInfoGetApplicationInfo :: (HasCallStack, MonadIO m) => RecentInfo -> Text -> m (Bool, Text, Word32, CTime)

-- | Retrieves the list of applications that have registered this resource.
--   
--   <i>Since: 2.10</i>
recentInfoGetApplications :: (HasCallStack, MonadIO m) => RecentInfo -> m ([Text], CSize)

-- | Gets the (short) description of the resource.
--   
--   <i>Since: 2.10</i>
recentInfoGetDescription :: (HasCallStack, MonadIO m) => RecentInfo -> m Text

-- | Gets the name of the resource. If none has been defined, the basename
--   of the resource is obtained.
--   
--   <i>Since: 2.10</i>
recentInfoGetDisplayName :: (HasCallStack, MonadIO m) => RecentInfo -> m Text

-- | Retrieves the icon associated to the resource MIME type.
--   
--   <i>Since: 2.22</i>
recentInfoGetGicon :: (HasCallStack, MonadIO m) => RecentInfo -> m (Maybe Icon)

-- | Returns all groups registered for the recently used item
--   <i><tt>info</tt></i>. The array of returned group names will be
--   <a>Nothing</a> terminated, so length might optionally be
--   <a>Nothing</a>.
--   
--   <i>Since: 2.10</i>
recentInfoGetGroups :: (HasCallStack, MonadIO m) => RecentInfo -> m ([Text], CSize)

-- | Retrieves the icon of size <i><tt>size</tt></i> associated to the
--   resource MIME type.
--   
--   <i>Since: 2.10</i>
recentInfoGetIcon :: (HasCallStack, MonadIO m) => RecentInfo -> Int32 -> m (Maybe Pixbuf)

-- | Gets the MIME type of the resource.
--   
--   <i>Since: 2.10</i>
recentInfoGetMimeType :: (HasCallStack, MonadIO m) => RecentInfo -> m Text

-- | Gets the timestamp (seconds from system’s Epoch) when the meta-data
--   for the resource was last modified.
--   
--   <i>Since: 2.10</i>
recentInfoGetModified :: (HasCallStack, MonadIO m) => RecentInfo -> m CTime

-- | Gets the value of the “private” flag. Resources in the recently used
--   list that have this flag set to <a>True</a> should only be displayed
--   by the applications that have registered them.
--   
--   <i>Since: 2.10</i>
recentInfoGetPrivateHint :: (HasCallStack, MonadIO m) => RecentInfo -> m Bool

-- | Computes a valid UTF-8 string that can be used as the name of the item
--   in a menu or list. For example, calling this function on an item that
--   refers to “file:///foo/bar.txt” will yield “bar.txt”.
--   
--   <i>Since: 2.10</i>
recentInfoGetShortName :: (HasCallStack, MonadIO m) => RecentInfo -> m Text

-- | Gets the URI of the resource.
--   
--   <i>Since: 2.10</i>
recentInfoGetUri :: (HasCallStack, MonadIO m) => RecentInfo -> m Text

-- | Gets a displayable version of the resource’s URI. If the resource is
--   local, it returns a local path; if the resource is not local, it
--   returns the UTF-8 encoded content of <a>recentInfoGetUri</a>.
--   
--   <i>Since: 2.10</i>
recentInfoGetUriDisplay :: (HasCallStack, MonadIO m) => RecentInfo -> m (Maybe Text)

-- | Gets the timestamp (seconds from system’s Epoch) when the meta-data
--   for the resource was last visited.
--   
--   <i>Since: 2.10</i>
recentInfoGetVisited :: (HasCallStack, MonadIO m) => RecentInfo -> m CTime

-- | Checks whether an application registered this resource using
--   <i><tt>appName</tt></i>.
--   
--   <i>Since: 2.10</i>
recentInfoHasApplication :: (HasCallStack, MonadIO m) => RecentInfo -> Text -> m Bool

-- | Checks whether <i><tt>groupName</tt></i> appears inside the groups
--   registered for the recently used item <i><tt>info</tt></i>.
--   
--   <i>Since: 2.10</i>
recentInfoHasGroup :: (HasCallStack, MonadIO m) => RecentInfo -> Text -> m Bool

-- | Checks whether the resource is local or not by looking at the scheme
--   of its URI.
--   
--   <i>Since: 2.10</i>
recentInfoIsLocal :: (HasCallStack, MonadIO m) => RecentInfo -> m Bool

-- | Gets the name of the last application that have registered the
--   recently used resource represented by <i><tt>info</tt></i>.
--   
--   <i>Since: 2.10</i>
recentInfoLastApplication :: (HasCallStack, MonadIO m) => RecentInfo -> m Text

-- | Checks whether two <a>RecentInfo</a>-struct point to the same
--   resource.
--   
--   <i>Since: 2.10</i>
recentInfoMatch :: (HasCallStack, MonadIO m) => RecentInfo -> RecentInfo -> m Bool

-- | Increases the reference count of <i><tt>recentInfo</tt></i> by one.
--   
--   <i>Since: 2.10</i>
recentInfoRef :: (HasCallStack, MonadIO m) => RecentInfo -> m RecentInfo

-- | Cast to <a>RecentManager</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toRecentManager :: (MonadIO m, IsRecentManager o) => o -> m RecentManager

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> recentManager #changed callback
--   </pre>
onRecentManagerChanged :: (IsRecentManager a, MonadIO m) => a -> ((?self :: a) => RecentManagerChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> recentManager #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterRecentManagerChanged :: (IsRecentManager a, MonadIO m) => a -> ((?self :: a) => RecentManagerChangedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>filename</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentManager #filename
--   </pre>
getRecentManagerFilename :: (MonadIO m, IsRecentManager o) => o -> m (Maybe Text)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>filename</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructRecentManagerFilename :: (IsRecentManager o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentManager #size
--   </pre>
getRecentManagerSize :: (MonadIO m, IsRecentManager o) => o -> m Int32

-- | Creates a new recent manager object. Recent manager objects are used
--   to handle the list of recently used resources. A <a>RecentManager</a>
--   object monitors the recently used resources list, and emits the
--   “changed” signal each time something inside the list changes.
--   
--   <a>RecentManager</a> objects are expensive: be sure to create them
--   only when needed. You should use <a>recentManagerGetDefault</a>
--   instead.
--   
--   <i>Since: 2.10</i>
recentManagerNew :: (HasCallStack, MonadIO m) => m RecentManager

-- | Adds a new resource, pointed by <i><tt>uri</tt></i>, into the recently
--   used resources list, using the metadata specified inside the
--   <a>RecentData</a>-struct passed in <i><tt>recentData</tt></i>.
--   
--   The passed URI will be used to identify this resource inside the list.
--   
--   In order to register the new recently used resource, metadata about
--   the resource must be passed as well as the URI; the metadata is stored
--   in a <a>RecentData</a>-struct, which must contain the MIME type of the
--   resource pointed by the URI; the name of the application that is
--   registering the item, and a command line to be used when launching the
--   item.
--   
--   Optionally, a <a>RecentData</a>-struct might contain a UTF-8 string to
--   be used when viewing the item instead of the last component of the
--   URI; a short description of the item; whether the item should be
--   considered private - that is, should be displayed only by the
--   applications that have registered it.
--   
--   <i>Since: 2.10</i>
recentManagerAddFull :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> RecentData -> m Bool

-- | Adds a new resource, pointed by <i><tt>uri</tt></i>, into the recently
--   used resources list.
--   
--   This function automatically retrieves some of the needed metadata and
--   setting other metadata to common default values; it then feeds the
--   data to <a>recentManagerAddFull</a>.
--   
--   See <a>recentManagerAddFull</a> if you want to explicitly define the
--   metadata for the resource pointed by <i><tt>uri</tt></i>.
--   
--   <i>Since: 2.10</i>
recentManagerAddItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> m Bool

-- | Gets the list of recently used resources.
--   
--   <i>Since: 2.10</i>
recentManagerGetItems :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> m [RecentInfo]

-- | Checks whether there is a recently used resource registered with
--   <i><tt>uri</tt></i> inside the recent manager.
--   
--   <i>Since: 2.10</i>
recentManagerHasItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> m Bool

-- | Searches for a URI inside the recently used resources list, and
--   returns a <a>RecentInfo</a>-struct containing informations about the
--   resource like its MIME type, or its display name.
--   
--   <i>Since: 2.10</i>
recentManagerLookupItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> m (Maybe RecentInfo)

-- | Changes the location of a recently used resource from
--   <i><tt>uri</tt></i> to <i><tt>newUri</tt></i>.
--   
--   Please note that this function will not affect the resource pointed by
--   the URIs, but only the URI used in the recently used resources list.
--   
--   <i>Since: 2.10</i>
recentManagerMoveItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> Maybe Text -> m ()

-- | Purges every item from the recently used resources list.
--   
--   <i>Since: 2.10</i>
recentManagerPurgeItems :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> m Int32

-- | Removes a resource pointed by <i><tt>uri</tt></i> from the recently
--   used resources list handled by a recent manager.
--   
--   <i>Since: 2.10</i>
recentManagerRemoveItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> m ()

-- | Gets a unique instance of <a>RecentManager</a>, that you can share in
--   your application without caring about memory management.
--   
--   <i>Since: 2.10</i>
recentManagerGetDefault :: (HasCallStack, MonadIO m) => m RecentManager

-- | Construct a <a>RequestedSize</a> struct initialized to zero.
newZeroRequestedSize :: MonadIO m => m RequestedSize

-- | Get the value of the “<tt>data</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> requestedSize #data
--   </pre>
getRequestedSizeData :: MonadIO m => RequestedSize -> m (Ptr ())

-- | Set the value of the “<tt>data</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> requestedSize [ #data <a>:=</a> value ]
--   </pre>
setRequestedSizeData :: MonadIO m => RequestedSize -> Ptr () -> m ()

-- | Set the value of the “<tt>data</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #data
--   </pre>
clearRequestedSizeData :: MonadIO m => RequestedSize -> m ()

-- | Get the value of the “<tt>minimum_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> requestedSize #minimumSize
--   </pre>
getRequestedSizeMinimumSize :: MonadIO m => RequestedSize -> m Int32

-- | Set the value of the “<tt>minimum_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> requestedSize [ #minimumSize <a>:=</a> value ]
--   </pre>
setRequestedSizeMinimumSize :: MonadIO m => RequestedSize -> Int32 -> m ()

-- | Get the value of the “<tt>natural_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> requestedSize #naturalSize
--   </pre>
getRequestedSizeNaturalSize :: MonadIO m => RequestedSize -> m Int32

-- | Set the value of the “<tt>natural_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> requestedSize [ #naturalSize <a>:=</a> value ]
--   </pre>
setRequestedSizeNaturalSize :: MonadIO m => RequestedSize -> Int32 -> m ()

-- | Construct a <a>Requisition</a> struct initialized to zero.
newZeroRequisition :: MonadIO m => m Requisition

-- | Get the value of the “<tt>width</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> requisition #width
--   </pre>
getRequisitionWidth :: MonadIO m => Requisition -> m Int32

-- | Set the value of the “<tt>width</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> requisition [ #width <a>:=</a> value ]
--   </pre>
setRequisitionWidth :: MonadIO m => Requisition -> Int32 -> m ()

-- | Get the value of the “<tt>height</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> requisition #height
--   </pre>
getRequisitionHeight :: MonadIO m => Requisition -> m Int32

-- | Set the value of the “<tt>height</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> requisition [ #height <a>:=</a> value ]
--   </pre>
setRequisitionHeight :: MonadIO m => Requisition -> Int32 -> m ()

-- | Allocates a new <a>Requisition</a>-struct and initializes its elements
--   to zero.
--   
--   <i>Since: 3.0</i>
requisitionNew :: (HasCallStack, MonadIO m) => m Requisition

-- | Copies a <a>Requisition</a>.
requisitionCopy :: (HasCallStack, MonadIO m) => Requisition -> m Requisition

-- | Frees a <a>Requisition</a>.
requisitionFree :: (HasCallStack, MonadIO m) => Requisition -> m ()

-- | Construct a <a>SettingsValue</a> struct initialized to zero.
newZeroSettingsValue :: MonadIO m => m SettingsValue

-- | Get the value of the “<tt>origin</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settingsValue #origin
--   </pre>
getSettingsValueOrigin :: MonadIO m => SettingsValue -> m (Maybe Text)

-- | Set the value of the “<tt>origin</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settingsValue [ #origin <a>:=</a> value ]
--   </pre>
setSettingsValueOrigin :: MonadIO m => SettingsValue -> CString -> m ()

-- | Set the value of the “<tt>origin</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #origin
--   </pre>
clearSettingsValueOrigin :: MonadIO m => SettingsValue -> m ()

-- | Get the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settingsValue #value
--   </pre>
getSettingsValueValue :: MonadIO m => SettingsValue -> m (Maybe GValue)

-- | Set the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settingsValue [ #value <a>:=</a> value ]
--   </pre>
setSettingsValueValue :: MonadIO m => SettingsValue -> Ptr GValue -> m ()

-- | Set the value of the “<tt>value</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #value
--   </pre>
clearSettingsValueValue :: MonadIO m => SettingsValue -> m ()

-- | Construct a <a>StockItem</a> struct initialized to zero.
newZeroStockItem :: MonadIO m => m StockItem

-- | Get the value of the “<tt>stock_id</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stockItem #stockId
--   </pre>
getStockItemStockId :: MonadIO m => StockItem -> m (Maybe Text)

-- | Set the value of the “<tt>stock_id</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stockItem [ #stockId <a>:=</a> value ]
--   </pre>
setStockItemStockId :: MonadIO m => StockItem -> CString -> m ()

-- | Set the value of the “<tt>stock_id</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #stockId
--   </pre>
clearStockItemStockId :: MonadIO m => StockItem -> m ()

-- | Get the value of the “<tt>label</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stockItem #label
--   </pre>
getStockItemLabel :: MonadIO m => StockItem -> m (Maybe Text)

-- | Set the value of the “<tt>label</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stockItem [ #label <a>:=</a> value ]
--   </pre>
setStockItemLabel :: MonadIO m => StockItem -> CString -> m ()

-- | Set the value of the “<tt>label</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #label
--   </pre>
clearStockItemLabel :: MonadIO m => StockItem -> m ()

-- | Get the value of the “<tt>modifier</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stockItem #modifier
--   </pre>
getStockItemModifier :: MonadIO m => StockItem -> m [ModifierType]

-- | Set the value of the “<tt>modifier</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stockItem [ #modifier <a>:=</a> value ]
--   </pre>
setStockItemModifier :: MonadIO m => StockItem -> [ModifierType] -> m ()

-- | Get the value of the “<tt>keyval</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stockItem #keyval
--   </pre>
getStockItemKeyval :: MonadIO m => StockItem -> m Word32

-- | Set the value of the “<tt>keyval</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stockItem [ #keyval <a>:=</a> value ]
--   </pre>
setStockItemKeyval :: MonadIO m => StockItem -> Word32 -> m ()

-- | Get the value of the “<tt>translation_domain</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stockItem #translationDomain
--   </pre>
getStockItemTranslationDomain :: MonadIO m => StockItem -> m (Maybe Text)

-- | Set the value of the “<tt>translation_domain</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stockItem [ #translationDomain <a>:=</a> value ]
--   </pre>
setStockItemTranslationDomain :: MonadIO m => StockItem -> CString -> m ()

-- | Set the value of the “<tt>translation_domain</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #translationDomain
--   </pre>
clearStockItemTranslationDomain :: MonadIO m => StockItem -> m ()

-- | Frees a stock item allocated on the heap, such as one returned by
--   <tt><i>gtk_stock_item_copy()</i></tt>. Also frees the fields inside
--   the stock item, if they are not <a>Nothing</a>.
stockItemFree :: (HasCallStack, MonadIO m) => StockItem -> m ()

-- | Construct a <a>TableRowCol</a> struct initialized to zero.
newZeroTableRowCol :: MonadIO m => m TableRowCol

-- | Get the value of the “<tt>requisition</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableRowCol #requisition
--   </pre>
getTableRowColRequisition :: MonadIO m => TableRowCol -> m Word16

-- | Set the value of the “<tt>requisition</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableRowCol [ #requisition <a>:=</a> value ]
--   </pre>
setTableRowColRequisition :: MonadIO m => TableRowCol -> Word16 -> m ()

-- | Get the value of the “<tt>allocation</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableRowCol #allocation
--   </pre>
getTableRowColAllocation :: MonadIO m => TableRowCol -> m Word16

-- | Set the value of the “<tt>allocation</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableRowCol [ #allocation <a>:=</a> value ]
--   </pre>
setTableRowColAllocation :: MonadIO m => TableRowCol -> Word16 -> m ()

-- | Get the value of the “<tt>spacing</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableRowCol #spacing
--   </pre>
getTableRowColSpacing :: MonadIO m => TableRowCol -> m Word16

-- | Set the value of the “<tt>spacing</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableRowCol [ #spacing <a>:=</a> value ]
--   </pre>
setTableRowColSpacing :: MonadIO m => TableRowCol -> Word16 -> m ()

-- | Get the value of the “<tt>need_expand</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableRowCol #needExpand
--   </pre>
getTableRowColNeedExpand :: MonadIO m => TableRowCol -> m Word32

-- | Set the value of the “<tt>need_expand</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableRowCol [ #needExpand <a>:=</a> value ]
--   </pre>
setTableRowColNeedExpand :: MonadIO m => TableRowCol -> Word32 -> m ()

-- | Get the value of the “<tt>need_shrink</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableRowCol #needShrink
--   </pre>
getTableRowColNeedShrink :: MonadIO m => TableRowCol -> m Word32

-- | Set the value of the “<tt>need_shrink</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableRowCol [ #needShrink <a>:=</a> value ]
--   </pre>
setTableRowColNeedShrink :: MonadIO m => TableRowCol -> Word32 -> m ()

-- | Get the value of the “<tt>expand</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableRowCol #expand
--   </pre>
getTableRowColExpand :: MonadIO m => TableRowCol -> m Word32

-- | Set the value of the “<tt>expand</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableRowCol [ #expand <a>:=</a> value ]
--   </pre>
setTableRowColExpand :: MonadIO m => TableRowCol -> Word32 -> m ()

-- | Get the value of the “<tt>shrink</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableRowCol #shrink
--   </pre>
getTableRowColShrink :: MonadIO m => TableRowCol -> m Word32

-- | Set the value of the “<tt>shrink</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableRowCol [ #shrink <a>:=</a> value ]
--   </pre>
setTableRowColShrink :: MonadIO m => TableRowCol -> Word32 -> m ()

-- | Get the value of the “<tt>empty</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableRowCol #empty
--   </pre>
getTableRowColEmpty :: MonadIO m => TableRowCol -> m Word32

-- | Set the value of the “<tt>empty</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableRowCol [ #empty <a>:=</a> value ]
--   </pre>
setTableRowColEmpty :: MonadIO m => TableRowCol -> Word32 -> m ()

-- | Construct a <a>TargetEntry</a> struct initialized to zero.
newZeroTargetEntry :: MonadIO m => m TargetEntry

-- | Get the value of the “<tt>target</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> targetEntry #target
--   </pre>
getTargetEntryTarget :: MonadIO m => TargetEntry -> m (Maybe Text)

-- | Set the value of the “<tt>target</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> targetEntry [ #target <a>:=</a> value ]
--   </pre>
setTargetEntryTarget :: MonadIO m => TargetEntry -> CString -> m ()

-- | Set the value of the “<tt>target</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #target
--   </pre>
clearTargetEntryTarget :: MonadIO m => TargetEntry -> m ()

-- | Get the value of the “<tt>flags</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> targetEntry #flags
--   </pre>
getTargetEntryFlags :: MonadIO m => TargetEntry -> m Word32

-- | Set the value of the “<tt>flags</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> targetEntry [ #flags <a>:=</a> value ]
--   </pre>
setTargetEntryFlags :: MonadIO m => TargetEntry -> Word32 -> m ()

-- | Get the value of the “<tt>info</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> targetEntry #info
--   </pre>
getTargetEntryInfo :: MonadIO m => TargetEntry -> m Word32

-- | Set the value of the “<tt>info</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> targetEntry [ #info <a>:=</a> value ]
--   </pre>
setTargetEntryInfo :: MonadIO m => TargetEntry -> Word32 -> m ()

-- | Makes a new <a>TargetEntry</a>.
targetEntryNew :: (HasCallStack, MonadIO m) => Text -> Word32 -> Word32 -> m TargetEntry

-- | Makes a copy of a <a>TargetEntry</a> and its data.
targetEntryCopy :: (HasCallStack, MonadIO m) => TargetEntry -> m TargetEntry

-- | Frees a <a>TargetEntry</a> returned from <a>targetEntryNew</a> or
--   <a>targetEntryCopy</a>.
targetEntryFree :: (HasCallStack, MonadIO m) => TargetEntry -> m ()

-- | Construct a <a>TargetPair</a> struct initialized to zero.
newZeroTargetPair :: MonadIO m => m TargetPair

-- | Get the value of the “<tt>target</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> targetPair #target
--   </pre>
getTargetPairTarget :: MonadIO m => TargetPair -> m Atom

-- | Get the value of the “<tt>flags</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> targetPair #flags
--   </pre>
getTargetPairFlags :: MonadIO m => TargetPair -> m Word32

-- | Set the value of the “<tt>flags</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> targetPair [ #flags <a>:=</a> value ]
--   </pre>
setTargetPairFlags :: MonadIO m => TargetPair -> Word32 -> m ()

-- | Get the value of the “<tt>info</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> targetPair #info
--   </pre>
getTargetPairInfo :: MonadIO m => TargetPair -> m Word32

-- | Set the value of the “<tt>info</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> targetPair [ #info <a>:=</a> value ]
--   </pre>
setTargetPairInfo :: MonadIO m => TargetPair -> Word32 -> m ()

-- | Construct a <a>TextAppearance</a> struct initialized to zero.
newZeroTextAppearance :: MonadIO m => m TextAppearance

-- | Get the value of the “<tt>bg_color</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAppearance #bgColor
--   </pre>
getTextAppearanceBgColor :: MonadIO m => TextAppearance -> m Color

-- | Get the value of the “<tt>fg_color</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAppearance #fgColor
--   </pre>
getTextAppearanceFgColor :: MonadIO m => TextAppearance -> m Color

-- | Get the value of the “<tt>rise</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAppearance #rise
--   </pre>
getTextAppearanceRise :: MonadIO m => TextAppearance -> m Int32

-- | Set the value of the “<tt>rise</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAppearance [ #rise <a>:=</a> value ]
--   </pre>
setTextAppearanceRise :: MonadIO m => TextAppearance -> Int32 -> m ()

-- | Get the value of the “<tt>underline</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAppearance #underline
--   </pre>
getTextAppearanceUnderline :: MonadIO m => TextAppearance -> m Word32

-- | Set the value of the “<tt>underline</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAppearance [ #underline <a>:=</a> value ]
--   </pre>
setTextAppearanceUnderline :: MonadIO m => TextAppearance -> Word32 -> m ()

-- | Get the value of the “<tt>strikethrough</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAppearance #strikethrough
--   </pre>
getTextAppearanceStrikethrough :: MonadIO m => TextAppearance -> m Word32

-- | Set the value of the “<tt>strikethrough</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAppearance [ #strikethrough <a>:=</a> value ]
--   </pre>
setTextAppearanceStrikethrough :: MonadIO m => TextAppearance -> Word32 -> m ()

-- | Get the value of the “<tt>draw_bg</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAppearance #drawBg
--   </pre>
getTextAppearanceDrawBg :: MonadIO m => TextAppearance -> m Word32

-- | Set the value of the “<tt>draw_bg</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAppearance [ #drawBg <a>:=</a> value ]
--   </pre>
setTextAppearanceDrawBg :: MonadIO m => TextAppearance -> Word32 -> m ()

-- | Get the value of the “<tt>inside_selection</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAppearance #insideSelection
--   </pre>
getTextAppearanceInsideSelection :: MonadIO m => TextAppearance -> m Word32

-- | Set the value of the “<tt>inside_selection</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAppearance [ #insideSelection <a>:=</a> value ]
--   </pre>
setTextAppearanceInsideSelection :: MonadIO m => TextAppearance -> Word32 -> m ()

-- | Get the value of the “<tt>is_text</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAppearance #isText
--   </pre>
getTextAppearanceIsText :: MonadIO m => TextAppearance -> m Word32

-- | Set the value of the “<tt>is_text</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAppearance [ #isText <a>:=</a> value ]
--   </pre>
setTextAppearanceIsText :: MonadIO m => TextAppearance -> Word32 -> m ()

-- | Construct a <a>TextAttributes</a> struct initialized to zero.
newZeroTextAttributes :: MonadIO m => m TextAttributes

-- | Get the value of the “<tt>appearance</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #appearance
--   </pre>
getTextAttributesAppearance :: MonadIO m => TextAttributes -> m TextAppearance

-- | Get the value of the “<tt>justification</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #justification
--   </pre>
getTextAttributesJustification :: MonadIO m => TextAttributes -> m Justification

-- | Set the value of the “<tt>justification</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #justification <a>:=</a> value ]
--   </pre>
setTextAttributesJustification :: MonadIO m => TextAttributes -> Justification -> m ()

-- | Get the value of the “<tt>direction</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #direction
--   </pre>
getTextAttributesDirection :: MonadIO m => TextAttributes -> m TextDirection

-- | Set the value of the “<tt>direction</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #direction <a>:=</a> value ]
--   </pre>
setTextAttributesDirection :: MonadIO m => TextAttributes -> TextDirection -> m ()

-- | Get the value of the “<tt>font</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #font
--   </pre>
getTextAttributesFont :: MonadIO m => TextAttributes -> m (Maybe FontDescription)

-- | Set the value of the “<tt>font</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #font <a>:=</a> value ]
--   </pre>
setTextAttributesFont :: MonadIO m => TextAttributes -> Ptr FontDescription -> m ()

-- | Set the value of the “<tt>font</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #font
--   </pre>
clearTextAttributesFont :: MonadIO m => TextAttributes -> m ()

-- | Get the value of the “<tt>font_scale</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #fontScale
--   </pre>
getTextAttributesFontScale :: MonadIO m => TextAttributes -> m Double

-- | Set the value of the “<tt>font_scale</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #fontScale <a>:=</a> value ]
--   </pre>
setTextAttributesFontScale :: MonadIO m => TextAttributes -> Double -> m ()

-- | Get the value of the “<tt>left_margin</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #leftMargin
--   </pre>
getTextAttributesLeftMargin :: MonadIO m => TextAttributes -> m Int32

-- | Set the value of the “<tt>left_margin</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #leftMargin <a>:=</a> value ]
--   </pre>
setTextAttributesLeftMargin :: MonadIO m => TextAttributes -> Int32 -> m ()

-- | Get the value of the “<tt>right_margin</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #rightMargin
--   </pre>
getTextAttributesRightMargin :: MonadIO m => TextAttributes -> m Int32

-- | Set the value of the “<tt>right_margin</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #rightMargin <a>:=</a> value ]
--   </pre>
setTextAttributesRightMargin :: MonadIO m => TextAttributes -> Int32 -> m ()

-- | Get the value of the “<tt>indent</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #indent
--   </pre>
getTextAttributesIndent :: MonadIO m => TextAttributes -> m Int32

-- | Set the value of the “<tt>indent</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #indent <a>:=</a> value ]
--   </pre>
setTextAttributesIndent :: MonadIO m => TextAttributes -> Int32 -> m ()

-- | Get the value of the “<tt>pixels_above_lines</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #pixelsAboveLines
--   </pre>
getTextAttributesPixelsAboveLines :: MonadIO m => TextAttributes -> m Int32

-- | Set the value of the “<tt>pixels_above_lines</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #pixelsAboveLines <a>:=</a> value ]
--   </pre>
setTextAttributesPixelsAboveLines :: MonadIO m => TextAttributes -> Int32 -> m ()

-- | Get the value of the “<tt>pixels_below_lines</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #pixelsBelowLines
--   </pre>
getTextAttributesPixelsBelowLines :: MonadIO m => TextAttributes -> m Int32

-- | Set the value of the “<tt>pixels_below_lines</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #pixelsBelowLines <a>:=</a> value ]
--   </pre>
setTextAttributesPixelsBelowLines :: MonadIO m => TextAttributes -> Int32 -> m ()

-- | Get the value of the “<tt>pixels_inside_wrap</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #pixelsInsideWrap
--   </pre>
getTextAttributesPixelsInsideWrap :: MonadIO m => TextAttributes -> m Int32

-- | Set the value of the “<tt>pixels_inside_wrap</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #pixelsInsideWrap <a>:=</a> value ]
--   </pre>
setTextAttributesPixelsInsideWrap :: MonadIO m => TextAttributes -> Int32 -> m ()

-- | Get the value of the “<tt>tabs</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #tabs
--   </pre>
getTextAttributesTabs :: MonadIO m => TextAttributes -> m (Maybe TabArray)

-- | Set the value of the “<tt>tabs</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #tabs <a>:=</a> value ]
--   </pre>
setTextAttributesTabs :: MonadIO m => TextAttributes -> Ptr TabArray -> m ()

-- | Set the value of the “<tt>tabs</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #tabs
--   </pre>
clearTextAttributesTabs :: MonadIO m => TextAttributes -> m ()

-- | Get the value of the “<tt>wrap_mode</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #wrapMode
--   </pre>
getTextAttributesWrapMode :: MonadIO m => TextAttributes -> m WrapMode

-- | Set the value of the “<tt>wrap_mode</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #wrapMode <a>:=</a> value ]
--   </pre>
setTextAttributesWrapMode :: MonadIO m => TextAttributes -> WrapMode -> m ()

-- | Get the value of the “<tt>language</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #language
--   </pre>
getTextAttributesLanguage :: MonadIO m => TextAttributes -> m (Maybe Language)

-- | Set the value of the “<tt>language</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #language <a>:=</a> value ]
--   </pre>
setTextAttributesLanguage :: MonadIO m => TextAttributes -> Ptr Language -> m ()

-- | Set the value of the “<tt>language</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #language
--   </pre>
clearTextAttributesLanguage :: MonadIO m => TextAttributes -> m ()

-- | Get the value of the “<tt>invisible</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #invisible
--   </pre>
getTextAttributesInvisible :: MonadIO m => TextAttributes -> m Word32

-- | Set the value of the “<tt>invisible</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #invisible <a>:=</a> value ]
--   </pre>
setTextAttributesInvisible :: MonadIO m => TextAttributes -> Word32 -> m ()

-- | Get the value of the “<tt>bg_full_height</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #bgFullHeight
--   </pre>
getTextAttributesBgFullHeight :: MonadIO m => TextAttributes -> m Word32

-- | Set the value of the “<tt>bg_full_height</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #bgFullHeight <a>:=</a> value ]
--   </pre>
setTextAttributesBgFullHeight :: MonadIO m => TextAttributes -> Word32 -> m ()

-- | Get the value of the “<tt>editable</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #editable
--   </pre>
getTextAttributesEditable :: MonadIO m => TextAttributes -> m Word32

-- | Set the value of the “<tt>editable</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #editable <a>:=</a> value ]
--   </pre>
setTextAttributesEditable :: MonadIO m => TextAttributes -> Word32 -> m ()

-- | Get the value of the “<tt>no_fallback</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #noFallback
--   </pre>
getTextAttributesNoFallback :: MonadIO m => TextAttributes -> m Word32

-- | Set the value of the “<tt>no_fallback</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #noFallback <a>:=</a> value ]
--   </pre>
setTextAttributesNoFallback :: MonadIO m => TextAttributes -> Word32 -> m ()

-- | Get the value of the “<tt>letter_spacing</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textAttributes #letterSpacing
--   </pre>
getTextAttributesLetterSpacing :: MonadIO m => TextAttributes -> m Int32

-- | Set the value of the “<tt>letter_spacing</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textAttributes [ #letterSpacing <a>:=</a> value ]
--   </pre>
setTextAttributesLetterSpacing :: MonadIO m => TextAttributes -> Int32 -> m ()

-- | Creates a <a>TextAttributes</a>, which describes a set of properties
--   on some text.
textAttributesNew :: (HasCallStack, MonadIO m) => m TextAttributes

-- | Copies <i><tt>src</tt></i> and returns a new <a>TextAttributes</a>.
textAttributesCopy :: (HasCallStack, MonadIO m) => TextAttributes -> m TextAttributes

-- | Copies the values from <i><tt>src</tt></i> to <i><tt>dest</tt></i> so
--   that <i><tt>dest</tt></i> has the same values as <i><tt>src</tt></i>.
--   Frees existing values in <i><tt>dest</tt></i>.
textAttributesCopyValues :: (HasCallStack, MonadIO m) => TextAttributes -> TextAttributes -> m ()

-- | Increments the reference count on <i><tt>values</tt></i>.
textAttributesRef :: (HasCallStack, MonadIO m) => TextAttributes -> m TextAttributes

-- | Construct a <a>ToggleActionEntry</a> struct initialized to zero.
newZeroToggleActionEntry :: MonadIO m => m ToggleActionEntry

-- | Get the value of the “<tt>name</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toggleActionEntry #name
--   </pre>
getToggleActionEntryName :: MonadIO m => ToggleActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>name</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toggleActionEntry [ #name <a>:=</a> value ]
--   </pre>
setToggleActionEntryName :: MonadIO m => ToggleActionEntry -> CString -> m ()

-- | Set the value of the “<tt>name</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #name
--   </pre>
clearToggleActionEntryName :: MonadIO m => ToggleActionEntry -> m ()

-- | Get the value of the “<tt>stock_id</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toggleActionEntry #stockId
--   </pre>
getToggleActionEntryStockId :: MonadIO m => ToggleActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>stock_id</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toggleActionEntry [ #stockId <a>:=</a> value ]
--   </pre>
setToggleActionEntryStockId :: MonadIO m => ToggleActionEntry -> CString -> m ()

-- | Set the value of the “<tt>stock_id</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #stockId
--   </pre>
clearToggleActionEntryStockId :: MonadIO m => ToggleActionEntry -> m ()

-- | Get the value of the “<tt>label</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toggleActionEntry #label
--   </pre>
getToggleActionEntryLabel :: MonadIO m => ToggleActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>label</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toggleActionEntry [ #label <a>:=</a> value ]
--   </pre>
setToggleActionEntryLabel :: MonadIO m => ToggleActionEntry -> CString -> m ()

-- | Set the value of the “<tt>label</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #label
--   </pre>
clearToggleActionEntryLabel :: MonadIO m => ToggleActionEntry -> m ()

-- | Get the value of the “<tt>accelerator</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toggleActionEntry #accelerator
--   </pre>
getToggleActionEntryAccelerator :: MonadIO m => ToggleActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>accelerator</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toggleActionEntry [ #accelerator <a>:=</a> value ]
--   </pre>
setToggleActionEntryAccelerator :: MonadIO m => ToggleActionEntry -> CString -> m ()

-- | Set the value of the “<tt>accelerator</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #accelerator
--   </pre>
clearToggleActionEntryAccelerator :: MonadIO m => ToggleActionEntry -> m ()

-- | Get the value of the “<tt>tooltip</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toggleActionEntry #tooltip
--   </pre>
getToggleActionEntryTooltip :: MonadIO m => ToggleActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>tooltip</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toggleActionEntry [ #tooltip <a>:=</a> value ]
--   </pre>
setToggleActionEntryTooltip :: MonadIO m => ToggleActionEntry -> CString -> m ()

-- | Set the value of the “<tt>tooltip</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #tooltip
--   </pre>
clearToggleActionEntryTooltip :: MonadIO m => ToggleActionEntry -> m ()

-- | Get the value of the “<tt>callback</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toggleActionEntry #callback
--   </pre>
getToggleActionEntryCallback :: MonadIO m => ToggleActionEntry -> m (Maybe Callback)

-- | Set the value of the “<tt>callback</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toggleActionEntry [ #callback <a>:=</a> value ]
--   </pre>
setToggleActionEntryCallback :: MonadIO m => ToggleActionEntry -> FunPtr C_Callback -> m ()

-- | Set the value of the “<tt>callback</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #callback
--   </pre>
clearToggleActionEntryCallback :: MonadIO m => ToggleActionEntry -> m ()

-- | Get the value of the “<tt>is_active</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toggleActionEntry #isActive
--   </pre>
getToggleActionEntryIsActive :: MonadIO m => ToggleActionEntry -> m Bool

-- | Set the value of the “<tt>is_active</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toggleActionEntry [ #isActive <a>:=</a> value ]
--   </pre>
setToggleActionEntryIsActive :: MonadIO m => ToggleActionEntry -> Bool -> m ()

-- | Construct a <a>TreeIter</a> struct initialized to zero.
newZeroTreeIter :: MonadIO m => m TreeIter

-- | Get the value of the “<tt>stamp</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeIter #stamp
--   </pre>
getTreeIterStamp :: MonadIO m => TreeIter -> m Int32

-- | Set the value of the “<tt>stamp</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeIter [ #stamp <a>:=</a> value ]
--   </pre>
setTreeIterStamp :: MonadIO m => TreeIter -> Int32 -> m ()

-- | Get the value of the “<tt>user_data</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeIter #userData
--   </pre>
getTreeIterUserData :: MonadIO m => TreeIter -> m (Ptr ())

-- | Set the value of the “<tt>user_data</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeIter [ #userData <a>:=</a> value ]
--   </pre>
setTreeIterUserData :: MonadIO m => TreeIter -> Ptr () -> m ()

-- | Set the value of the “<tt>user_data</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #userData
--   </pre>
clearTreeIterUserData :: MonadIO m => TreeIter -> m ()

-- | Get the value of the “<tt>user_data2</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeIter #userData2
--   </pre>
getTreeIterUserData2 :: MonadIO m => TreeIter -> m (Ptr ())

-- | Set the value of the “<tt>user_data2</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeIter [ #userData2 <a>:=</a> value ]
--   </pre>
setTreeIterUserData2 :: MonadIO m => TreeIter -> Ptr () -> m ()

-- | Set the value of the “<tt>user_data2</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #userData2
--   </pre>
clearTreeIterUserData2 :: MonadIO m => TreeIter -> m ()

-- | Get the value of the “<tt>user_data3</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeIter #userData3
--   </pre>
getTreeIterUserData3 :: MonadIO m => TreeIter -> m (Ptr ())

-- | Set the value of the “<tt>user_data3</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeIter [ #userData3 <a>:=</a> value ]
--   </pre>
setTreeIterUserData3 :: MonadIO m => TreeIter -> Ptr () -> m ()

-- | Set the value of the “<tt>user_data3</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #userData3
--   </pre>
clearTreeIterUserData3 :: MonadIO m => TreeIter -> m ()

-- | Creates a dynamically allocated tree iterator as a copy of
--   <i><tt>iter</tt></i>.
--   
--   This function is not intended for use in applications, because you can
--   just copy the structs by value (<tt>GtkTreeIter new_iter =
--   iter;</tt>). You must free this iter with <a>treeIterFree</a>.
treeIterCopy :: (HasCallStack, MonadIO m) => TreeIter -> m TreeIter

-- | Frees an iterator that has been allocated by <a>treeIterCopy</a>.
--   
--   This function is mainly used for language bindings.
treeIterFree :: (HasCallStack, MonadIO m) => TreeIter -> m ()

-- | Creates a new <a>TreePath</a>-struct. This refers to a row.
treePathNew :: (HasCallStack, MonadIO m) => m TreePath

-- | Creates a new <a>TreePath</a>-struct.
--   
--   The string representation of this path is “0”.
treePathNewFirst :: (HasCallStack, MonadIO m) => m TreePath

-- | Creates a new path with the given <i><tt>indices</tt></i> array of
--   <i><tt>length</tt></i>.
--   
--   <i>Since: 3.12</i>
treePathNewFromIndices :: (HasCallStack, MonadIO m) => [Int32] -> m TreePath

-- | Creates a new <a>TreePath</a>-struct initialized to
--   <i><tt>path</tt></i>.
--   
--   <i><tt>path</tt></i> is expected to be a colon separated list of
--   numbers. For example, the string “10:4:0” would create a path of depth
--   3 pointing to the 11th child of the root node, the 5th child of that
--   11th child, and the 1st child of that 5th child. If an invalid path
--   string is passed in, <a>Nothing</a> is returned.
treePathNewFromString :: (HasCallStack, MonadIO m) => Text -> m TreePath

-- | Appends a new index to a path.
--   
--   As a result, the depth of the path is increased.
treePathAppendIndex :: (HasCallStack, MonadIO m) => TreePath -> Int32 -> m ()

-- | Compares two paths.
--   
--   If <i><tt>a</tt></i> appears before <i><tt>b</tt></i> in a tree, then
--   -1 is returned. If <i><tt>b</tt></i> appears before <i><tt>a</tt></i>,
--   then 1 is returned. If the two nodes are equal, then 0 is returned.
treePathCompare :: (HasCallStack, MonadIO m) => TreePath -> TreePath -> m Int32

-- | Creates a new <a>TreePath</a>-struct as a copy of
--   <i><tt>path</tt></i>.
treePathCopy :: (HasCallStack, MonadIO m) => TreePath -> m TreePath

-- | Moves <i><tt>path</tt></i> to point to the first child of the current
--   path.
treePathDown :: (HasCallStack, MonadIO m) => TreePath -> m ()

-- | Returns the current depth of <i><tt>path</tt></i>.
treePathGetDepth :: (HasCallStack, MonadIO m) => TreePath -> m Int32

-- | Returns the current indices of <i><tt>path</tt></i>.
--   
--   This is an array of integers, each representing a node in a tree. It
--   also returns the number of elements in the array. The array should not
--   be freed.
--   
--   <i>Since: 3.0</i>
treePathGetIndices :: (HasCallStack, MonadIO m) => TreePath -> m (Maybe [Int32])

-- | Returns <a>True</a> if <i><tt>descendant</tt></i> is a descendant of
--   <i><tt>path</tt></i>.
treePathIsAncestor :: (HasCallStack, MonadIO m) => TreePath -> TreePath -> m Bool

-- | Returns <a>True</a> if <i><tt>path</tt></i> is a descendant of
--   <i><tt>ancestor</tt></i>.
treePathIsDescendant :: (HasCallStack, MonadIO m) => TreePath -> TreePath -> m Bool

-- | Moves the <i><tt>path</tt></i> to point to the next node at the
--   current depth.
treePathNext :: (HasCallStack, MonadIO m) => TreePath -> m ()

-- | Prepends a new index to a path.
--   
--   As a result, the depth of the path is increased.
treePathPrependIndex :: (HasCallStack, MonadIO m) => TreePath -> Int32 -> m ()

-- | Moves the <i><tt>path</tt></i> to point to the previous node at the
--   current depth, if it exists.
treePathPrev :: (HasCallStack, MonadIO m) => TreePath -> m Bool

-- | Generates a string representation of the path.
--   
--   This string is a “:” separated list of numbers. For example,
--   “4:10:0:3” would be an acceptable return value for this string.
treePathToString :: (HasCallStack, MonadIO m) => TreePath -> m Text

-- | Moves the <i><tt>path</tt></i> to point to its parent node, if it has
--   a parent.
treePathUp :: (HasCallStack, MonadIO m) => TreePath -> m Bool

-- | Cast to <a>Calendar</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toCalendar :: (MonadIO m, IsCalendar o) => o -> m Calendar

-- | Cast to <a>FlowBox</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toFlowBox :: (MonadIO m, IsFlowBox o) => o -> m FlowBox

-- | Cast to <a>FlowBoxChild</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFlowBoxChild :: (MonadIO m, IsFlowBoxChild o) => o -> m FlowBoxChild

-- | Cast to <a>IconView</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toIconView :: (MonadIO m, IsIconView o) => o -> m IconView

-- | Cast to <a>ListBox</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toListBox :: (MonadIO m, IsListBox o) => o -> m ListBox

-- | Cast to <a>ListBoxRow</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toListBoxRow :: (MonadIO m, IsListBoxRow o) => o -> m ListBoxRow

-- | Cast to <a>Actionable</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toActionable :: (MonadIO m, IsActionable o) => o -> m Actionable

-- | Cast to <a>Activatable</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toActivatable :: (MonadIO m, IsActivatable o) => o -> m Activatable

-- | Cast to <a>Action</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toAction :: (MonadIO m, IsAction o) => o -> m Action

-- | Cast to <a>ActionGroup</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toActionGroup :: (MonadIO m, IsActionGroup o) => o -> m ActionGroup

-- | Cast to <a>Menu</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toMenu :: (MonadIO m, IsMenu o) => o -> m Menu

-- | Cast to <a>MenuItem</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toMenuItem :: (MonadIO m, IsMenuItem o) => o -> m MenuItem

-- | Cast to <a>MenuShell</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMenuShell :: (MonadIO m, IsMenuShell o) => o -> m MenuShell

-- | Cast to <a>Entry</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toEntry :: (MonadIO m, IsEntry o) => o -> m Entry

-- | Cast to <a>EntryCompletion</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toEntryCompletion :: (MonadIO m, IsEntryCompletion o) => o -> m EntryCompletion

-- | Cast to <a>TreeSelection</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeSelection :: (MonadIO m, IsTreeSelection o) => o -> m TreeSelection

-- | Cast to <a>TreeView</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toTreeView :: (MonadIO m, IsTreeView o) => o -> m TreeView

-- | Cast to <a>CellLayout</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCellLayout :: (MonadIO m, IsCellLayout o) => o -> m CellLayout

-- | Cast to <a>TreeModel</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeModel :: (MonadIO m, IsTreeModel o) => o -> m TreeModel

-- | Cast to <a>CellArea</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toCellArea :: (MonadIO m, IsCellArea o) => o -> m CellArea

-- | Cast to <a>CellAreaContext</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toCellAreaContext :: (MonadIO m, IsCellAreaContext o) => o -> m CellAreaContext

-- | Cast to <a>CellEditable</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCellEditable :: (MonadIO m, IsCellEditable o) => o -> m CellEditable

-- | Cast to <a>Buildable</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toBuildable :: (MonadIO m, IsBuildable o) => o -> m Buildable

-- | Cast to <a>CellRenderer</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCellRenderer :: (MonadIO m, IsCellRenderer o) => o -> m CellRenderer

-- | Cast to <a>TreeViewColumn</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeViewColumn :: (MonadIO m, IsTreeViewColumn o) => o -> m TreeViewColumn

-- | Cast to <a>AccelGroup</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAccelGroup :: (MonadIO m, IsAccelGroup o) => o -> m AccelGroup

-- | Cast to <a>Application</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toApplication :: (MonadIO m, IsApplication o) => o -> m Application

-- | Cast to <a>Bin</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toBin :: (MonadIO m, IsBin o) => o -> m Bin

-- | Cast to <a>Builder</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toBuilder :: (MonadIO m, IsBuilder o) => o -> m Builder

-- | Cast to <a>Clipboard</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toClipboard :: (MonadIO m, IsClipboard o) => o -> m Clipboard

-- | Cast to <a>Container</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toContainer :: (MonadIO m, IsContainer o) => o -> m Container

-- | Cast to <a>IconFactory</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toIconFactory :: (MonadIO m, IsIconFactory o) => o -> m IconFactory

-- | Cast to <a>Settings</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toSettings :: (MonadIO m, IsSettings o) => o -> m Settings

-- | Cast to <a>Style</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toStyle :: (MonadIO m, IsStyle o) => o -> m Style

-- | Cast to <a>StyleContext</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toStyleContext :: (MonadIO m, IsStyleContext o) => o -> m StyleContext

-- | Cast to <a>StyleProperties</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toStyleProperties :: (MonadIO m, IsStyleProperties o) => o -> m StyleProperties

-- | Cast to <a>TextBuffer</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTextBuffer :: (MonadIO m, IsTextBuffer o) => o -> m TextBuffer

-- | Cast to <a>TextChildAnchor</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toTextChildAnchor :: (MonadIO m, IsTextChildAnchor o) => o -> m TextChildAnchor

-- | Cast to <a>TextMark</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toTextMark :: (MonadIO m, IsTextMark o) => o -> m TextMark

-- | Cast to <a>TextTag</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toTextTag :: (MonadIO m, IsTextTag o) => o -> m TextTag

-- | Cast to <a>TextTagTable</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTextTagTable :: (MonadIO m, IsTextTagTable o) => o -> m TextTagTable

-- | Cast to <a>Tooltip</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toTooltip :: (MonadIO m, IsTooltip o) => o -> m Tooltip

-- | Cast to <a>Widget</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toWidget :: (MonadIO m, IsWidget o) => o -> m Widget

-- | Cast to <a>WindowGroup</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toWindowGroup :: (MonadIO m, IsWindowGroup o) => o -> m WindowGroup

-- | Generate a function pointer callable from C code, from a
--   <a>C_AccelGroupActivate</a>.
mk_AccelGroupActivate :: C_AccelGroupActivate -> IO (FunPtr C_AccelGroupActivate)

-- | Generate a function pointer callable from C code, from a
--   <a>C_AccelGroupFindFunc</a>.
mk_AccelGroupFindFunc :: C_AccelGroupFindFunc -> IO (FunPtr C_AccelGroupFindFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_AccelMapForeach</a>.
mk_AccelMapForeach :: C_AccelMapForeach -> IO (FunPtr C_AccelMapForeach)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ActionableInterfaceGetActionNameFieldCallback</a>.
mk_ActionableInterfaceGetActionNameFieldCallback :: C_ActionableInterfaceGetActionNameFieldCallback -> IO (FunPtr C_ActionableInterfaceGetActionNameFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ActionableInterfaceGetActionTargetValueFieldCallback</a>.
mk_ActionableInterfaceGetActionTargetValueFieldCallback :: C_ActionableInterfaceGetActionTargetValueFieldCallback -> IO (FunPtr C_ActionableInterfaceGetActionTargetValueFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ActionableInterfaceSetActionNameFieldCallback</a>.
mk_ActionableInterfaceSetActionNameFieldCallback :: C_ActionableInterfaceSetActionNameFieldCallback -> IO (FunPtr C_ActionableInterfaceSetActionNameFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ActionableInterfaceSetActionTargetValueFieldCallback</a>.
mk_ActionableInterfaceSetActionTargetValueFieldCallback :: C_ActionableInterfaceSetActionTargetValueFieldCallback -> IO (FunPtr C_ActionableInterfaceSetActionTargetValueFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_AssistantPageFunc</a>.
mk_AssistantPageFunc :: C_AssistantPageFunc -> IO (FunPtr C_AssistantPageFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_BuilderConnectFunc</a>.
mk_BuilderConnectFunc :: C_BuilderConnectFunc -> IO (FunPtr C_BuilderConnectFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_CalendarDetailFunc</a>.
mk_CalendarDetailFunc :: C_CalendarDetailFunc -> IO (FunPtr C_CalendarDetailFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_CellAllocCallback</a>.
mk_CellAllocCallback :: C_CellAllocCallback -> IO (FunPtr C_CellAllocCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_CellCallback</a>.
mk_CellCallback :: C_CellCallback -> IO (FunPtr C_CellCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_CellLayoutDataFunc</a>.
mk_CellLayoutDataFunc :: C_CellLayoutDataFunc -> IO (FunPtr C_CellLayoutDataFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ClipboardClearFunc</a>.
mk_ClipboardClearFunc :: C_ClipboardClearFunc -> IO (FunPtr C_ClipboardClearFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ClipboardGetFunc</a>.
mk_ClipboardGetFunc :: C_ClipboardGetFunc -> IO (FunPtr C_ClipboardGetFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ClipboardImageReceivedFunc</a>.
mk_ClipboardImageReceivedFunc :: C_ClipboardImageReceivedFunc -> IO (FunPtr C_ClipboardImageReceivedFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ClipboardReceivedFunc</a>.
mk_ClipboardReceivedFunc :: C_ClipboardReceivedFunc -> IO (FunPtr C_ClipboardReceivedFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ClipboardRichTextReceivedFunc</a>.
mk_ClipboardRichTextReceivedFunc :: C_ClipboardRichTextReceivedFunc -> IO (FunPtr C_ClipboardRichTextReceivedFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ClipboardTargetsReceivedFunc</a>.
mk_ClipboardTargetsReceivedFunc :: C_ClipboardTargetsReceivedFunc -> IO (FunPtr C_ClipboardTargetsReceivedFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ClipboardTextReceivedFunc</a>.
mk_ClipboardTextReceivedFunc :: C_ClipboardTextReceivedFunc -> IO (FunPtr C_ClipboardTextReceivedFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ClipboardURIReceivedFunc</a>.
mk_ClipboardURIReceivedFunc :: C_ClipboardURIReceivedFunc -> IO (FunPtr C_ClipboardURIReceivedFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ColorSelectionChangePaletteFunc</a>.
mk_ColorSelectionChangePaletteFunc :: C_ColorSelectionChangePaletteFunc -> IO (FunPtr C_ColorSelectionChangePaletteFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ColorSelectionChangePaletteWithScreenFunc</a>.
mk_ColorSelectionChangePaletteWithScreenFunc :: C_ColorSelectionChangePaletteWithScreenFunc -> IO (FunPtr C_ColorSelectionChangePaletteWithScreenFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ContainerClassAddFieldCallback</a>.
mk_ContainerClassAddFieldCallback :: C_ContainerClassAddFieldCallback -> IO (FunPtr C_ContainerClassAddFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ContainerClassCheckResizeFieldCallback</a>.
mk_ContainerClassCheckResizeFieldCallback :: C_ContainerClassCheckResizeFieldCallback -> IO (FunPtr C_ContainerClassCheckResizeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ContainerClassChildTypeFieldCallback</a>.
mk_ContainerClassChildTypeFieldCallback :: C_ContainerClassChildTypeFieldCallback -> IO (FunPtr C_ContainerClassChildTypeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ContainerClassCompositeNameFieldCallback</a>.
mk_ContainerClassCompositeNameFieldCallback :: C_ContainerClassCompositeNameFieldCallback -> IO (FunPtr C_ContainerClassCompositeNameFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ContainerClassForallFieldCallback</a>.
mk_ContainerClassForallFieldCallback :: C_ContainerClassForallFieldCallback -> IO (FunPtr C_ContainerClassForallFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ContainerClassGetChildPropertyFieldCallback</a>.
mk_ContainerClassGetChildPropertyFieldCallback :: C_ContainerClassGetChildPropertyFieldCallback -> IO (FunPtr C_ContainerClassGetChildPropertyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ContainerClassGetPathForChildFieldCallback</a>.
mk_ContainerClassGetPathForChildFieldCallback :: C_ContainerClassGetPathForChildFieldCallback -> IO (FunPtr C_ContainerClassGetPathForChildFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ContainerClassRemoveFieldCallback</a>.
mk_ContainerClassRemoveFieldCallback :: C_ContainerClassRemoveFieldCallback -> IO (FunPtr C_ContainerClassRemoveFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ContainerClassSetChildPropertyFieldCallback</a>.
mk_ContainerClassSetChildPropertyFieldCallback :: C_ContainerClassSetChildPropertyFieldCallback -> IO (FunPtr C_ContainerClassSetChildPropertyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ContainerClassSetFocusChildFieldCallback</a>.
mk_ContainerClassSetFocusChildFieldCallback :: C_ContainerClassSetFocusChildFieldCallback -> IO (FunPtr C_ContainerClassSetFocusChildFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_EntryCompletionMatchFunc</a>.
mk_EntryCompletionMatchFunc :: C_EntryCompletionMatchFunc -> IO (FunPtr C_EntryCompletionMatchFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_FileFilterFunc</a>.
mk_FileFilterFunc :: C_FileFilterFunc -> IO (FunPtr C_FileFilterFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_FlowBoxCreateWidgetFunc</a>.
mk_FlowBoxCreateWidgetFunc :: C_FlowBoxCreateWidgetFunc -> IO (FunPtr C_FlowBoxCreateWidgetFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_FlowBoxFilterFunc</a>.
mk_FlowBoxFilterFunc :: C_FlowBoxFilterFunc -> IO (FunPtr C_FlowBoxFilterFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_FlowBoxForeachFunc</a>.
mk_FlowBoxForeachFunc :: C_FlowBoxForeachFunc -> IO (FunPtr C_FlowBoxForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_FlowBoxSortFunc</a>.
mk_FlowBoxSortFunc :: C_FlowBoxSortFunc -> IO (FunPtr C_FlowBoxSortFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_FontFilterFunc</a>.
mk_FontFilterFunc :: C_FontFilterFunc -> IO (FunPtr C_FontFilterFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_IconViewForeachFunc</a>.
mk_IconViewForeachFunc :: C_IconViewForeachFunc -> IO (FunPtr C_IconViewForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_KeySnoopFunc</a>.
mk_KeySnoopFunc :: C_KeySnoopFunc -> IO (FunPtr C_KeySnoopFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ListBoxCreateWidgetFunc</a>.
mk_ListBoxCreateWidgetFunc :: C_ListBoxCreateWidgetFunc -> IO (FunPtr C_ListBoxCreateWidgetFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ListBoxFilterFunc</a>.
mk_ListBoxFilterFunc :: C_ListBoxFilterFunc -> IO (FunPtr C_ListBoxFilterFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ListBoxForeachFunc</a>.
mk_ListBoxForeachFunc :: C_ListBoxForeachFunc -> IO (FunPtr C_ListBoxForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ListBoxSortFunc</a>.
mk_ListBoxSortFunc :: C_ListBoxSortFunc -> IO (FunPtr C_ListBoxSortFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ListBoxUpdateHeaderFunc</a>.
mk_ListBoxUpdateHeaderFunc :: C_ListBoxUpdateHeaderFunc -> IO (FunPtr C_ListBoxUpdateHeaderFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_MenuDetachFunc</a>.
mk_MenuDetachFunc :: C_MenuDetachFunc -> IO (FunPtr C_MenuDetachFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_MenuPositionFunc</a>.
mk_MenuPositionFunc :: C_MenuPositionFunc -> IO (FunPtr C_MenuPositionFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ModuleDisplayInitFunc</a>.
mk_ModuleDisplayInitFunc :: C_ModuleDisplayInitFunc -> IO (FunPtr C_ModuleDisplayInitFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ModuleInitFunc</a>.
mk_ModuleInitFunc :: C_ModuleInitFunc -> IO (FunPtr C_ModuleInitFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_PageSetupDoneFunc</a>.
mk_PageSetupDoneFunc :: C_PageSetupDoneFunc -> IO (FunPtr C_PageSetupDoneFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_PrintSettingsFunc</a>.
mk_PrintSettingsFunc :: C_PrintSettingsFunc -> IO (FunPtr C_PrintSettingsFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_RcPropertyParser</a>.
mk_RcPropertyParser :: C_RcPropertyParser -> IO (FunPtr C_RcPropertyParser)

-- | Generate a function pointer callable from C code, from a
--   <a>C_RecentFilterFunc</a>.
mk_RecentFilterFunc :: C_RecentFilterFunc -> IO (FunPtr C_RecentFilterFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_RecentSortFunc</a>.
mk_RecentSortFunc :: C_RecentSortFunc -> IO (FunPtr C_RecentSortFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_StylePropertyParser</a>.
mk_StylePropertyParser :: C_StylePropertyParser -> IO (FunPtr C_StylePropertyParser)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TextBufferDeserializeFunc</a>.
mk_TextBufferDeserializeFunc :: C_TextBufferDeserializeFunc -> IO (FunPtr C_TextBufferDeserializeFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TextBufferSerializeFunc</a>.
mk_TextBufferSerializeFunc :: C_TextBufferSerializeFunc -> IO (FunPtr C_TextBufferSerializeFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TextCharPredicate</a>.
mk_TextCharPredicate :: C_TextCharPredicate -> IO (FunPtr C_TextCharPredicate)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TextTagTableForeach</a>.
mk_TextTagTableForeach :: C_TextTagTableForeach -> IO (FunPtr C_TextTagTableForeach)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TickCallback</a>.
mk_TickCallback :: C_TickCallback -> IO (FunPtr C_TickCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeCellDataFunc</a>.
mk_TreeCellDataFunc :: C_TreeCellDataFunc -> IO (FunPtr C_TreeCellDataFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeDestroyCountFunc</a>.
mk_TreeDestroyCountFunc :: C_TreeDestroyCountFunc -> IO (FunPtr C_TreeDestroyCountFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeIterCompareFunc</a>.
mk_TreeIterCompareFunc :: C_TreeIterCompareFunc -> IO (FunPtr C_TreeIterCompareFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeModelFilterModifyFunc</a>.
mk_TreeModelFilterModifyFunc :: C_TreeModelFilterModifyFunc -> IO (FunPtr C_TreeModelFilterModifyFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeModelFilterVisibleFunc</a>.
mk_TreeModelFilterVisibleFunc :: C_TreeModelFilterVisibleFunc -> IO (FunPtr C_TreeModelFilterVisibleFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeModelForeachFunc</a>.
mk_TreeModelForeachFunc :: C_TreeModelForeachFunc -> IO (FunPtr C_TreeModelForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeSelectionForeachFunc</a>.
mk_TreeSelectionForeachFunc :: C_TreeSelectionForeachFunc -> IO (FunPtr C_TreeSelectionForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeSelectionFunc</a>.
mk_TreeSelectionFunc :: C_TreeSelectionFunc -> IO (FunPtr C_TreeSelectionFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeViewColumnDropFunc</a>.
mk_TreeViewColumnDropFunc :: C_TreeViewColumnDropFunc -> IO (FunPtr C_TreeViewColumnDropFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeViewMappingFunc</a>.
mk_TreeViewMappingFunc :: C_TreeViewMappingFunc -> IO (FunPtr C_TreeViewMappingFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeViewRowSeparatorFunc</a>.
mk_TreeViewRowSeparatorFunc :: C_TreeViewRowSeparatorFunc -> IO (FunPtr C_TreeViewRowSeparatorFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeViewSearchEqualFunc</a>.
mk_TreeViewSearchEqualFunc :: C_TreeViewSearchEqualFunc -> IO (FunPtr C_TreeViewSearchEqualFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeViewSearchPositionFunc</a>.
mk_TreeViewSearchPositionFunc :: C_TreeViewSearchPositionFunc -> IO (FunPtr C_TreeViewSearchPositionFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassAdjustBaselineAllocationFieldCallback</a>.
mk_WidgetClassAdjustBaselineAllocationFieldCallback :: C_WidgetClassAdjustBaselineAllocationFieldCallback -> IO (FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassAdjustBaselineRequestFieldCallback</a>.
mk_WidgetClassAdjustBaselineRequestFieldCallback :: C_WidgetClassAdjustBaselineRequestFieldCallback -> IO (FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassAdjustSizeAllocationFieldCallback</a>.
mk_WidgetClassAdjustSizeAllocationFieldCallback :: C_WidgetClassAdjustSizeAllocationFieldCallback -> IO (FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassAdjustSizeRequestFieldCallback</a>.
mk_WidgetClassAdjustSizeRequestFieldCallback :: C_WidgetClassAdjustSizeRequestFieldCallback -> IO (FunPtr C_WidgetClassAdjustSizeRequestFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassButtonPressEventFieldCallback</a>.
mk_WidgetClassButtonPressEventFieldCallback :: C_WidgetClassButtonPressEventFieldCallback -> IO (FunPtr C_WidgetClassButtonPressEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassButtonReleaseEventFieldCallback</a>.
mk_WidgetClassButtonReleaseEventFieldCallback :: C_WidgetClassButtonReleaseEventFieldCallback -> IO (FunPtr C_WidgetClassButtonReleaseEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassCanActivateAccelFieldCallback</a>.
mk_WidgetClassCanActivateAccelFieldCallback :: C_WidgetClassCanActivateAccelFieldCallback -> IO (FunPtr C_WidgetClassCanActivateAccelFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassChildNotifyFieldCallback</a>.
mk_WidgetClassChildNotifyFieldCallback :: C_WidgetClassChildNotifyFieldCallback -> IO (FunPtr C_WidgetClassChildNotifyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassCompositedChangedFieldCallback</a>.
mk_WidgetClassCompositedChangedFieldCallback :: C_WidgetClassCompositedChangedFieldCallback -> IO (FunPtr C_WidgetClassCompositedChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassComputeExpandFieldCallback</a>.
mk_WidgetClassComputeExpandFieldCallback :: C_WidgetClassComputeExpandFieldCallback -> IO (FunPtr C_WidgetClassComputeExpandFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassConfigureEventFieldCallback</a>.
mk_WidgetClassConfigureEventFieldCallback :: C_WidgetClassConfigureEventFieldCallback -> IO (FunPtr C_WidgetClassConfigureEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDamageEventFieldCallback</a>.
mk_WidgetClassDamageEventFieldCallback :: C_WidgetClassDamageEventFieldCallback -> IO (FunPtr C_WidgetClassDamageEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDeleteEventFieldCallback</a>.
mk_WidgetClassDeleteEventFieldCallback :: C_WidgetClassDeleteEventFieldCallback -> IO (FunPtr C_WidgetClassDeleteEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDestroyEventFieldCallback</a>.
mk_WidgetClassDestroyEventFieldCallback :: C_WidgetClassDestroyEventFieldCallback -> IO (FunPtr C_WidgetClassDestroyEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDestroyFieldCallback</a>.
mk_WidgetClassDestroyFieldCallback :: C_WidgetClassDestroyFieldCallback -> IO (FunPtr C_WidgetClassDestroyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDirectionChangedFieldCallback</a>.
mk_WidgetClassDirectionChangedFieldCallback :: C_WidgetClassDirectionChangedFieldCallback -> IO (FunPtr C_WidgetClassDirectionChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDispatchChildPropertiesChangedFieldCallback</a>.
mk_WidgetClassDispatchChildPropertiesChangedFieldCallback :: C_WidgetClassDispatchChildPropertiesChangedFieldCallback -> IO (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDragBeginFieldCallback</a>.
mk_WidgetClassDragBeginFieldCallback :: C_WidgetClassDragBeginFieldCallback -> IO (FunPtr C_WidgetClassDragBeginFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDragDataDeleteFieldCallback</a>.
mk_WidgetClassDragDataDeleteFieldCallback :: C_WidgetClassDragDataDeleteFieldCallback -> IO (FunPtr C_WidgetClassDragDataDeleteFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDragDataGetFieldCallback</a>.
mk_WidgetClassDragDataGetFieldCallback :: C_WidgetClassDragDataGetFieldCallback -> IO (FunPtr C_WidgetClassDragDataGetFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDragDataReceivedFieldCallback</a>.
mk_WidgetClassDragDataReceivedFieldCallback :: C_WidgetClassDragDataReceivedFieldCallback -> IO (FunPtr C_WidgetClassDragDataReceivedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDragDropFieldCallback</a>.
mk_WidgetClassDragDropFieldCallback :: C_WidgetClassDragDropFieldCallback -> IO (FunPtr C_WidgetClassDragDropFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDragEndFieldCallback</a>.
mk_WidgetClassDragEndFieldCallback :: C_WidgetClassDragEndFieldCallback -> IO (FunPtr C_WidgetClassDragEndFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDragFailedFieldCallback</a>.
mk_WidgetClassDragFailedFieldCallback :: C_WidgetClassDragFailedFieldCallback -> IO (FunPtr C_WidgetClassDragFailedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDragLeaveFieldCallback</a>.
mk_WidgetClassDragLeaveFieldCallback :: C_WidgetClassDragLeaveFieldCallback -> IO (FunPtr C_WidgetClassDragLeaveFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDragMotionFieldCallback</a>.
mk_WidgetClassDragMotionFieldCallback :: C_WidgetClassDragMotionFieldCallback -> IO (FunPtr C_WidgetClassDragMotionFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDrawFieldCallback</a>.
mk_WidgetClassDrawFieldCallback :: C_WidgetClassDrawFieldCallback -> IO (FunPtr C_WidgetClassDrawFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassEnterNotifyEventFieldCallback</a>.
mk_WidgetClassEnterNotifyEventFieldCallback :: C_WidgetClassEnterNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassEnterNotifyEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassEventFieldCallback</a>.
mk_WidgetClassEventFieldCallback :: C_WidgetClassEventFieldCallback -> IO (FunPtr C_WidgetClassEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassFocusFieldCallback</a>.
mk_WidgetClassFocusFieldCallback :: C_WidgetClassFocusFieldCallback -> IO (FunPtr C_WidgetClassFocusFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassFocusInEventFieldCallback</a>.
mk_WidgetClassFocusInEventFieldCallback :: C_WidgetClassFocusInEventFieldCallback -> IO (FunPtr C_WidgetClassFocusInEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassFocusOutEventFieldCallback</a>.
mk_WidgetClassFocusOutEventFieldCallback :: C_WidgetClassFocusOutEventFieldCallback -> IO (FunPtr C_WidgetClassFocusOutEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassGetAccessibleFieldCallback</a>.
mk_WidgetClassGetAccessibleFieldCallback :: C_WidgetClassGetAccessibleFieldCallback -> IO (FunPtr C_WidgetClassGetAccessibleFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback</a>.
mk_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassGetPreferredHeightFieldCallback</a>.
mk_WidgetClassGetPreferredHeightFieldCallback :: C_WidgetClassGetPreferredHeightFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredHeightFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassGetPreferredHeightForWidthFieldCallback</a>.
mk_WidgetClassGetPreferredHeightForWidthFieldCallback :: C_WidgetClassGetPreferredHeightForWidthFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredHeightForWidthFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassGetPreferredWidthFieldCallback</a>.
mk_WidgetClassGetPreferredWidthFieldCallback :: C_WidgetClassGetPreferredWidthFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredWidthFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassGetPreferredWidthForHeightFieldCallback</a>.
mk_WidgetClassGetPreferredWidthForHeightFieldCallback :: C_WidgetClassGetPreferredWidthForHeightFieldCallback -> IO (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassGetRequestModeFieldCallback</a>.
mk_WidgetClassGetRequestModeFieldCallback :: C_WidgetClassGetRequestModeFieldCallback -> IO (FunPtr C_WidgetClassGetRequestModeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassGrabBrokenEventFieldCallback</a>.
mk_WidgetClassGrabBrokenEventFieldCallback :: C_WidgetClassGrabBrokenEventFieldCallback -> IO (FunPtr C_WidgetClassGrabBrokenEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassGrabFocusFieldCallback</a>.
mk_WidgetClassGrabFocusFieldCallback :: C_WidgetClassGrabFocusFieldCallback -> IO (FunPtr C_WidgetClassGrabFocusFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassGrabNotifyFieldCallback</a>.
mk_WidgetClassGrabNotifyFieldCallback :: C_WidgetClassGrabNotifyFieldCallback -> IO (FunPtr C_WidgetClassGrabNotifyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassHideFieldCallback</a>.
mk_WidgetClassHideFieldCallback :: C_WidgetClassHideFieldCallback -> IO (FunPtr C_WidgetClassHideFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassHierarchyChangedFieldCallback</a>.
mk_WidgetClassHierarchyChangedFieldCallback :: C_WidgetClassHierarchyChangedFieldCallback -> IO (FunPtr C_WidgetClassHierarchyChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassKeyPressEventFieldCallback</a>.
mk_WidgetClassKeyPressEventFieldCallback :: C_WidgetClassKeyPressEventFieldCallback -> IO (FunPtr C_WidgetClassKeyPressEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassKeyReleaseEventFieldCallback</a>.
mk_WidgetClassKeyReleaseEventFieldCallback :: C_WidgetClassKeyReleaseEventFieldCallback -> IO (FunPtr C_WidgetClassKeyReleaseEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassKeynavFailedFieldCallback</a>.
mk_WidgetClassKeynavFailedFieldCallback :: C_WidgetClassKeynavFailedFieldCallback -> IO (FunPtr C_WidgetClassKeynavFailedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassLeaveNotifyEventFieldCallback</a>.
mk_WidgetClassLeaveNotifyEventFieldCallback :: C_WidgetClassLeaveNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassLeaveNotifyEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassMapEventFieldCallback</a>.
mk_WidgetClassMapEventFieldCallback :: C_WidgetClassMapEventFieldCallback -> IO (FunPtr C_WidgetClassMapEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassMapFieldCallback</a>.
mk_WidgetClassMapFieldCallback :: C_WidgetClassMapFieldCallback -> IO (FunPtr C_WidgetClassMapFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassMnemonicActivateFieldCallback</a>.
mk_WidgetClassMnemonicActivateFieldCallback :: C_WidgetClassMnemonicActivateFieldCallback -> IO (FunPtr C_WidgetClassMnemonicActivateFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassMotionNotifyEventFieldCallback</a>.
mk_WidgetClassMotionNotifyEventFieldCallback :: C_WidgetClassMotionNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassMotionNotifyEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassMoveFocusFieldCallback</a>.
mk_WidgetClassMoveFocusFieldCallback :: C_WidgetClassMoveFocusFieldCallback -> IO (FunPtr C_WidgetClassMoveFocusFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassParentSetFieldCallback</a>.
mk_WidgetClassParentSetFieldCallback :: C_WidgetClassParentSetFieldCallback -> IO (FunPtr C_WidgetClassParentSetFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassPopupMenuFieldCallback</a>.
mk_WidgetClassPopupMenuFieldCallback :: C_WidgetClassPopupMenuFieldCallback -> IO (FunPtr C_WidgetClassPopupMenuFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassPropertyNotifyEventFieldCallback</a>.
mk_WidgetClassPropertyNotifyEventFieldCallback :: C_WidgetClassPropertyNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassPropertyNotifyEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassProximityInEventFieldCallback</a>.
mk_WidgetClassProximityInEventFieldCallback :: C_WidgetClassProximityInEventFieldCallback -> IO (FunPtr C_WidgetClassProximityInEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassProximityOutEventFieldCallback</a>.
mk_WidgetClassProximityOutEventFieldCallback :: C_WidgetClassProximityOutEventFieldCallback -> IO (FunPtr C_WidgetClassProximityOutEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassQueryTooltipFieldCallback</a>.
mk_WidgetClassQueryTooltipFieldCallback :: C_WidgetClassQueryTooltipFieldCallback -> IO (FunPtr C_WidgetClassQueryTooltipFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassQueueDrawRegionFieldCallback</a>.
mk_WidgetClassQueueDrawRegionFieldCallback :: C_WidgetClassQueueDrawRegionFieldCallback -> IO (FunPtr C_WidgetClassQueueDrawRegionFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassRealizeFieldCallback</a>.
mk_WidgetClassRealizeFieldCallback :: C_WidgetClassRealizeFieldCallback -> IO (FunPtr C_WidgetClassRealizeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassScreenChangedFieldCallback</a>.
mk_WidgetClassScreenChangedFieldCallback :: C_WidgetClassScreenChangedFieldCallback -> IO (FunPtr C_WidgetClassScreenChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassScrollEventFieldCallback</a>.
mk_WidgetClassScrollEventFieldCallback :: C_WidgetClassScrollEventFieldCallback -> IO (FunPtr C_WidgetClassScrollEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassSelectionClearEventFieldCallback</a>.
mk_WidgetClassSelectionClearEventFieldCallback :: C_WidgetClassSelectionClearEventFieldCallback -> IO (FunPtr C_WidgetClassSelectionClearEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassSelectionGetFieldCallback</a>.
mk_WidgetClassSelectionGetFieldCallback :: C_WidgetClassSelectionGetFieldCallback -> IO (FunPtr C_WidgetClassSelectionGetFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassSelectionNotifyEventFieldCallback</a>.
mk_WidgetClassSelectionNotifyEventFieldCallback :: C_WidgetClassSelectionNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassSelectionNotifyEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassSelectionReceivedFieldCallback</a>.
mk_WidgetClassSelectionReceivedFieldCallback :: C_WidgetClassSelectionReceivedFieldCallback -> IO (FunPtr C_WidgetClassSelectionReceivedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassSelectionRequestEventFieldCallback</a>.
mk_WidgetClassSelectionRequestEventFieldCallback :: C_WidgetClassSelectionRequestEventFieldCallback -> IO (FunPtr C_WidgetClassSelectionRequestEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassShowAllFieldCallback</a>.
mk_WidgetClassShowAllFieldCallback :: C_WidgetClassShowAllFieldCallback -> IO (FunPtr C_WidgetClassShowAllFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassShowFieldCallback</a>.
mk_WidgetClassShowFieldCallback :: C_WidgetClassShowFieldCallback -> IO (FunPtr C_WidgetClassShowFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassShowHelpFieldCallback</a>.
mk_WidgetClassShowHelpFieldCallback :: C_WidgetClassShowHelpFieldCallback -> IO (FunPtr C_WidgetClassShowHelpFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassSizeAllocateFieldCallback</a>.
mk_WidgetClassSizeAllocateFieldCallback :: C_WidgetClassSizeAllocateFieldCallback -> IO (FunPtr C_WidgetClassSizeAllocateFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassStateChangedFieldCallback</a>.
mk_WidgetClassStateChangedFieldCallback :: C_WidgetClassStateChangedFieldCallback -> IO (FunPtr C_WidgetClassStateChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassStateFlagsChangedFieldCallback</a>.
mk_WidgetClassStateFlagsChangedFieldCallback :: C_WidgetClassStateFlagsChangedFieldCallback -> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassStyleSetFieldCallback</a>.
mk_WidgetClassStyleSetFieldCallback :: C_WidgetClassStyleSetFieldCallback -> IO (FunPtr C_WidgetClassStyleSetFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassStyleUpdatedFieldCallback</a>.
mk_WidgetClassStyleUpdatedFieldCallback :: C_WidgetClassStyleUpdatedFieldCallback -> IO (FunPtr C_WidgetClassStyleUpdatedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassTouchEventFieldCallback</a>.
mk_WidgetClassTouchEventFieldCallback :: C_WidgetClassTouchEventFieldCallback -> IO (FunPtr C_WidgetClassTouchEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassUnmapEventFieldCallback</a>.
mk_WidgetClassUnmapEventFieldCallback :: C_WidgetClassUnmapEventFieldCallback -> IO (FunPtr C_WidgetClassUnmapEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassUnmapFieldCallback</a>.
mk_WidgetClassUnmapFieldCallback :: C_WidgetClassUnmapFieldCallback -> IO (FunPtr C_WidgetClassUnmapFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassUnrealizeFieldCallback</a>.
mk_WidgetClassUnrealizeFieldCallback :: C_WidgetClassUnrealizeFieldCallback -> IO (FunPtr C_WidgetClassUnrealizeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassVisibilityNotifyEventFieldCallback</a>.
mk_WidgetClassVisibilityNotifyEventFieldCallback :: C_WidgetClassVisibilityNotifyEventFieldCallback -> IO (FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassWindowStateEventFieldCallback</a>.
mk_WidgetClassWindowStateEventFieldCallback :: C_WidgetClassWindowStateEventFieldCallback -> IO (FunPtr C_WidgetClassWindowStateEventFieldCallback)

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassWindowStateEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassWindowStateEventFieldCallback -> a -> EventWindowState -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassWindowStateEventFieldCallback</a></tt>.
noWidgetClassWindowStateEventFieldCallback :: Maybe WidgetClassWindowStateEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassWindowStateEventFieldCallback :: MonadIO m => WidgetClassWindowStateEventFieldCallback -> m (GClosure C_WidgetClassWindowStateEventFieldCallback)

-- | Wrap a <a>WidgetClassWindowStateEventFieldCallback</a> into a
--   <a>C_WidgetClassWindowStateEventFieldCallback</a>.
wrap_WidgetClassWindowStateEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassWindowStateEventFieldCallback)) -> WidgetClassWindowStateEventFieldCallback -> C_WidgetClassWindowStateEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassVisibilityNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback -> a -> EventVisibility -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassVisibilityNotifyEventFieldCallback</a></tt>.
noWidgetClassVisibilityNotifyEventFieldCallback :: Maybe WidgetClassVisibilityNotifyEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassVisibilityNotifyEventFieldCallback :: MonadIO m => WidgetClassVisibilityNotifyEventFieldCallback -> m (GClosure C_WidgetClassVisibilityNotifyEventFieldCallback)

-- | Wrap a <a>WidgetClassVisibilityNotifyEventFieldCallback</a> into a
--   <a>C_WidgetClassVisibilityNotifyEventFieldCallback</a>.
wrap_WidgetClassVisibilityNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback)) -> WidgetClassVisibilityNotifyEventFieldCallback -> C_WidgetClassVisibilityNotifyEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassUnrealizeFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassUnrealizeFieldCallback -> a -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassUnrealizeFieldCallback</a></tt>.
noWidgetClassUnrealizeFieldCallback :: Maybe WidgetClassUnrealizeFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassUnrealizeFieldCallback :: MonadIO m => WidgetClassUnrealizeFieldCallback -> m (GClosure C_WidgetClassUnrealizeFieldCallback)

-- | Wrap a <a>WidgetClassUnrealizeFieldCallback</a> into a
--   <a>C_WidgetClassUnrealizeFieldCallback</a>.
wrap_WidgetClassUnrealizeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnrealizeFieldCallback)) -> WidgetClassUnrealizeFieldCallback -> C_WidgetClassUnrealizeFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassUnmapFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassUnmapFieldCallback -> a -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassUnmapFieldCallback</a></tt>.
noWidgetClassUnmapFieldCallback :: Maybe WidgetClassUnmapFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassUnmapFieldCallback :: MonadIO m => WidgetClassUnmapFieldCallback -> m (GClosure C_WidgetClassUnmapFieldCallback)

-- | Wrap a <a>WidgetClassUnmapFieldCallback</a> into a
--   <a>C_WidgetClassUnmapFieldCallback</a>.
wrap_WidgetClassUnmapFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnmapFieldCallback)) -> WidgetClassUnmapFieldCallback -> C_WidgetClassUnmapFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassUnmapEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassUnmapEventFieldCallback -> a -> EventAny -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassUnmapEventFieldCallback</a></tt>.
noWidgetClassUnmapEventFieldCallback :: Maybe WidgetClassUnmapEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassUnmapEventFieldCallback :: MonadIO m => WidgetClassUnmapEventFieldCallback -> m (GClosure C_WidgetClassUnmapEventFieldCallback)

-- | Wrap a <a>WidgetClassUnmapEventFieldCallback</a> into a
--   <a>C_WidgetClassUnmapEventFieldCallback</a>.
wrap_WidgetClassUnmapEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnmapEventFieldCallback)) -> WidgetClassUnmapEventFieldCallback -> C_WidgetClassUnmapEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassTouchEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassTouchEventFieldCallback -> a -> EventTouch -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassTouchEventFieldCallback</a></tt>.
noWidgetClassTouchEventFieldCallback :: Maybe WidgetClassTouchEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassTouchEventFieldCallback :: MonadIO m => WidgetClassTouchEventFieldCallback -> m (GClosure C_WidgetClassTouchEventFieldCallback)

-- | Wrap a <a>WidgetClassTouchEventFieldCallback</a> into a
--   <a>C_WidgetClassTouchEventFieldCallback</a>.
wrap_WidgetClassTouchEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassTouchEventFieldCallback)) -> WidgetClassTouchEventFieldCallback -> C_WidgetClassTouchEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassStyleUpdatedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassStyleUpdatedFieldCallback -> a -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassStyleUpdatedFieldCallback</a></tt>.
noWidgetClassStyleUpdatedFieldCallback :: Maybe WidgetClassStyleUpdatedFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassStyleUpdatedFieldCallback :: MonadIO m => WidgetClassStyleUpdatedFieldCallback -> m (GClosure C_WidgetClassStyleUpdatedFieldCallback)

-- | Wrap a <a>WidgetClassStyleUpdatedFieldCallback</a> into a
--   <a>C_WidgetClassStyleUpdatedFieldCallback</a>.
wrap_WidgetClassStyleUpdatedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStyleUpdatedFieldCallback)) -> WidgetClassStyleUpdatedFieldCallback -> C_WidgetClassStyleUpdatedFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassStyleSetFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsStyle b) => FunPtr C_WidgetClassStyleSetFieldCallback -> a -> b -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassStyleSetFieldCallback</a></tt>.
noWidgetClassStyleSetFieldCallback :: Maybe WidgetClassStyleSetFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassStyleSetFieldCallback :: MonadIO m => WidgetClassStyleSetFieldCallback -> m (GClosure C_WidgetClassStyleSetFieldCallback)

-- | Wrap a <a>WidgetClassStyleSetFieldCallback</a> into a
--   <a>C_WidgetClassStyleSetFieldCallback</a>.
wrap_WidgetClassStyleSetFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStyleSetFieldCallback)) -> WidgetClassStyleSetFieldCallback -> C_WidgetClassStyleSetFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassStateFlagsChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> a -> [StateFlags] -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassStateFlagsChangedFieldCallback</a></tt>.
noWidgetClassStateFlagsChangedFieldCallback :: Maybe WidgetClassStateFlagsChangedFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassStateFlagsChangedFieldCallback :: MonadIO m => WidgetClassStateFlagsChangedFieldCallback -> m (GClosure C_WidgetClassStateFlagsChangedFieldCallback)

-- | Wrap a <a>WidgetClassStateFlagsChangedFieldCallback</a> into a
--   <a>C_WidgetClassStateFlagsChangedFieldCallback</a>.
wrap_WidgetClassStateFlagsChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)) -> WidgetClassStateFlagsChangedFieldCallback -> C_WidgetClassStateFlagsChangedFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassStateChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassStateChangedFieldCallback -> a -> StateType -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassStateChangedFieldCallback</a></tt>.
noWidgetClassStateChangedFieldCallback :: Maybe WidgetClassStateChangedFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassStateChangedFieldCallback :: MonadIO m => WidgetClassStateChangedFieldCallback -> m (GClosure C_WidgetClassStateChangedFieldCallback)

-- | Wrap a <a>WidgetClassStateChangedFieldCallback</a> into a
--   <a>C_WidgetClassStateChangedFieldCallback</a>.
wrap_WidgetClassStateChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStateChangedFieldCallback)) -> WidgetClassStateChangedFieldCallback -> C_WidgetClassStateChangedFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassSizeAllocateFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSizeAllocateFieldCallback -> a -> Rectangle -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassSizeAllocateFieldCallback</a></tt>.
noWidgetClassSizeAllocateFieldCallback :: Maybe WidgetClassSizeAllocateFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassSizeAllocateFieldCallback :: MonadIO m => WidgetClassSizeAllocateFieldCallback -> m (GClosure C_WidgetClassSizeAllocateFieldCallback)

-- | Wrap a <a>WidgetClassSizeAllocateFieldCallback</a> into a
--   <a>C_WidgetClassSizeAllocateFieldCallback</a>.
wrap_WidgetClassSizeAllocateFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)) -> WidgetClassSizeAllocateFieldCallback -> C_WidgetClassSizeAllocateFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassShowHelpFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassShowHelpFieldCallback -> a -> WidgetHelpType -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassShowHelpFieldCallback</a></tt>.
noWidgetClassShowHelpFieldCallback :: Maybe WidgetClassShowHelpFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassShowHelpFieldCallback :: MonadIO m => WidgetClassShowHelpFieldCallback -> m (GClosure C_WidgetClassShowHelpFieldCallback)

-- | Wrap a <a>WidgetClassShowHelpFieldCallback</a> into a
--   <a>C_WidgetClassShowHelpFieldCallback</a>.
wrap_WidgetClassShowHelpFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassShowHelpFieldCallback)) -> WidgetClassShowHelpFieldCallback -> C_WidgetClassShowHelpFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassShowFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassShowFieldCallback -> a -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassShowFieldCallback</a></tt>.
noWidgetClassShowFieldCallback :: Maybe WidgetClassShowFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassShowFieldCallback :: MonadIO m => WidgetClassShowFieldCallback -> m (GClosure C_WidgetClassShowFieldCallback)

-- | Wrap a <a>WidgetClassShowFieldCallback</a> into a
--   <a>C_WidgetClassShowFieldCallback</a>.
wrap_WidgetClassShowFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassShowFieldCallback)) -> WidgetClassShowFieldCallback -> C_WidgetClassShowFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassShowAllFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassShowAllFieldCallback -> a -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassShowAllFieldCallback</a></tt>.
noWidgetClassShowAllFieldCallback :: Maybe WidgetClassShowAllFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassShowAllFieldCallback :: MonadIO m => WidgetClassShowAllFieldCallback -> m (GClosure C_WidgetClassShowAllFieldCallback)

-- | Wrap a <a>WidgetClassShowAllFieldCallback</a> into a
--   <a>C_WidgetClassShowAllFieldCallback</a>.
wrap_WidgetClassShowAllFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassShowAllFieldCallback)) -> WidgetClassShowAllFieldCallback -> C_WidgetClassShowAllFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassSelectionRequestEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionRequestEventFieldCallback -> a -> EventSelection -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassSelectionRequestEventFieldCallback</a></tt>.
noWidgetClassSelectionRequestEventFieldCallback :: Maybe WidgetClassSelectionRequestEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassSelectionRequestEventFieldCallback :: MonadIO m => WidgetClassSelectionRequestEventFieldCallback -> m (GClosure C_WidgetClassSelectionRequestEventFieldCallback)

-- | Wrap a <a>WidgetClassSelectionRequestEventFieldCallback</a> into a
--   <a>C_WidgetClassSelectionRequestEventFieldCallback</a>.
wrap_WidgetClassSelectionRequestEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionRequestEventFieldCallback)) -> WidgetClassSelectionRequestEventFieldCallback -> C_WidgetClassSelectionRequestEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassSelectionReceivedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionReceivedFieldCallback -> a -> SelectionData -> Word32 -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassSelectionReceivedFieldCallback</a></tt>.
noWidgetClassSelectionReceivedFieldCallback :: Maybe WidgetClassSelectionReceivedFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassSelectionReceivedFieldCallback :: MonadIO m => WidgetClassSelectionReceivedFieldCallback -> m (GClosure C_WidgetClassSelectionReceivedFieldCallback)

-- | Wrap a <a>WidgetClassSelectionReceivedFieldCallback</a> into a
--   <a>C_WidgetClassSelectionReceivedFieldCallback</a>.
wrap_WidgetClassSelectionReceivedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionReceivedFieldCallback)) -> WidgetClassSelectionReceivedFieldCallback -> C_WidgetClassSelectionReceivedFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassSelectionNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionNotifyEventFieldCallback -> a -> EventSelection -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassSelectionNotifyEventFieldCallback</a></tt>.
noWidgetClassSelectionNotifyEventFieldCallback :: Maybe WidgetClassSelectionNotifyEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassSelectionNotifyEventFieldCallback :: MonadIO m => WidgetClassSelectionNotifyEventFieldCallback -> m (GClosure C_WidgetClassSelectionNotifyEventFieldCallback)

-- | Wrap a <a>WidgetClassSelectionNotifyEventFieldCallback</a> into a
--   <a>C_WidgetClassSelectionNotifyEventFieldCallback</a>.
wrap_WidgetClassSelectionNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionNotifyEventFieldCallback)) -> WidgetClassSelectionNotifyEventFieldCallback -> C_WidgetClassSelectionNotifyEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassSelectionGetFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionGetFieldCallback -> a -> SelectionData -> Word32 -> Word32 -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassSelectionGetFieldCallback</a></tt>.
noWidgetClassSelectionGetFieldCallback :: Maybe WidgetClassSelectionGetFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassSelectionGetFieldCallback :: MonadIO m => WidgetClassSelectionGetFieldCallback -> m (GClosure C_WidgetClassSelectionGetFieldCallback)

-- | Wrap a <a>WidgetClassSelectionGetFieldCallback</a> into a
--   <a>C_WidgetClassSelectionGetFieldCallback</a>.
wrap_WidgetClassSelectionGetFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionGetFieldCallback)) -> WidgetClassSelectionGetFieldCallback -> C_WidgetClassSelectionGetFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassSelectionClearEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSelectionClearEventFieldCallback -> a -> EventSelection -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassSelectionClearEventFieldCallback</a></tt>.
noWidgetClassSelectionClearEventFieldCallback :: Maybe WidgetClassSelectionClearEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassSelectionClearEventFieldCallback :: MonadIO m => WidgetClassSelectionClearEventFieldCallback -> m (GClosure C_WidgetClassSelectionClearEventFieldCallback)

-- | Wrap a <a>WidgetClassSelectionClearEventFieldCallback</a> into a
--   <a>C_WidgetClassSelectionClearEventFieldCallback</a>.
wrap_WidgetClassSelectionClearEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSelectionClearEventFieldCallback)) -> WidgetClassSelectionClearEventFieldCallback -> C_WidgetClassSelectionClearEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassScrollEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassScrollEventFieldCallback -> a -> EventScroll -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassScrollEventFieldCallback</a></tt>.
noWidgetClassScrollEventFieldCallback :: Maybe WidgetClassScrollEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassScrollEventFieldCallback :: MonadIO m => WidgetClassScrollEventFieldCallback -> m (GClosure C_WidgetClassScrollEventFieldCallback)

-- | Wrap a <a>WidgetClassScrollEventFieldCallback</a> into a
--   <a>C_WidgetClassScrollEventFieldCallback</a>.
wrap_WidgetClassScrollEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassScrollEventFieldCallback)) -> WidgetClassScrollEventFieldCallback -> C_WidgetClassScrollEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassScreenChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsScreen b) => FunPtr C_WidgetClassScreenChangedFieldCallback -> a -> b -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassScreenChangedFieldCallback</a></tt>.
noWidgetClassScreenChangedFieldCallback :: Maybe WidgetClassScreenChangedFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassScreenChangedFieldCallback :: MonadIO m => WidgetClassScreenChangedFieldCallback -> m (GClosure C_WidgetClassScreenChangedFieldCallback)

-- | Wrap a <a>WidgetClassScreenChangedFieldCallback</a> into a
--   <a>C_WidgetClassScreenChangedFieldCallback</a>.
wrap_WidgetClassScreenChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassScreenChangedFieldCallback)) -> WidgetClassScreenChangedFieldCallback -> C_WidgetClassScreenChangedFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassRealizeFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassRealizeFieldCallback -> a -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassRealizeFieldCallback</a></tt>.
noWidgetClassRealizeFieldCallback :: Maybe WidgetClassRealizeFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassRealizeFieldCallback :: MonadIO m => WidgetClassRealizeFieldCallback -> m (GClosure C_WidgetClassRealizeFieldCallback)

-- | Wrap a <a>WidgetClassRealizeFieldCallback</a> into a
--   <a>C_WidgetClassRealizeFieldCallback</a>.
wrap_WidgetClassRealizeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassRealizeFieldCallback)) -> WidgetClassRealizeFieldCallback -> C_WidgetClassRealizeFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassQueueDrawRegionFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassQueueDrawRegionFieldCallback -> a -> Region -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassQueueDrawRegionFieldCallback</a></tt>.
noWidgetClassQueueDrawRegionFieldCallback :: Maybe WidgetClassQueueDrawRegionFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassQueueDrawRegionFieldCallback :: MonadIO m => WidgetClassQueueDrawRegionFieldCallback -> m (GClosure C_WidgetClassQueueDrawRegionFieldCallback)

-- | Wrap a <a>WidgetClassQueueDrawRegionFieldCallback</a> into a
--   <a>C_WidgetClassQueueDrawRegionFieldCallback</a>.
wrap_WidgetClassQueueDrawRegionFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassQueueDrawRegionFieldCallback)) -> WidgetClassQueueDrawRegionFieldCallback -> C_WidgetClassQueueDrawRegionFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassQueryTooltipFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsTooltip b) => FunPtr C_WidgetClassQueryTooltipFieldCallback -> a -> Int32 -> Int32 -> Bool -> b -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassQueryTooltipFieldCallback</a></tt>.
noWidgetClassQueryTooltipFieldCallback :: Maybe WidgetClassQueryTooltipFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassQueryTooltipFieldCallback :: MonadIO m => WidgetClassQueryTooltipFieldCallback -> m (GClosure C_WidgetClassQueryTooltipFieldCallback)

-- | Wrap a <a>WidgetClassQueryTooltipFieldCallback</a> into a
--   <a>C_WidgetClassQueryTooltipFieldCallback</a>.
wrap_WidgetClassQueryTooltipFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)) -> WidgetClassQueryTooltipFieldCallback -> C_WidgetClassQueryTooltipFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassProximityOutEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassProximityOutEventFieldCallback -> a -> EventProximity -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassProximityOutEventFieldCallback</a></tt>.
noWidgetClassProximityOutEventFieldCallback :: Maybe WidgetClassProximityOutEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassProximityOutEventFieldCallback :: MonadIO m => WidgetClassProximityOutEventFieldCallback -> m (GClosure C_WidgetClassProximityOutEventFieldCallback)

-- | Wrap a <a>WidgetClassProximityOutEventFieldCallback</a> into a
--   <a>C_WidgetClassProximityOutEventFieldCallback</a>.
wrap_WidgetClassProximityOutEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassProximityOutEventFieldCallback)) -> WidgetClassProximityOutEventFieldCallback -> C_WidgetClassProximityOutEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassProximityInEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassProximityInEventFieldCallback -> a -> EventProximity -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassProximityInEventFieldCallback</a></tt>.
noWidgetClassProximityInEventFieldCallback :: Maybe WidgetClassProximityInEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassProximityInEventFieldCallback :: MonadIO m => WidgetClassProximityInEventFieldCallback -> m (GClosure C_WidgetClassProximityInEventFieldCallback)

-- | Wrap a <a>WidgetClassProximityInEventFieldCallback</a> into a
--   <a>C_WidgetClassProximityInEventFieldCallback</a>.
wrap_WidgetClassProximityInEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassProximityInEventFieldCallback)) -> WidgetClassProximityInEventFieldCallback -> C_WidgetClassProximityInEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassPropertyNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassPropertyNotifyEventFieldCallback -> a -> EventProperty -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassPropertyNotifyEventFieldCallback</a></tt>.
noWidgetClassPropertyNotifyEventFieldCallback :: Maybe WidgetClassPropertyNotifyEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassPropertyNotifyEventFieldCallback :: MonadIO m => WidgetClassPropertyNotifyEventFieldCallback -> m (GClosure C_WidgetClassPropertyNotifyEventFieldCallback)

-- | Wrap a <a>WidgetClassPropertyNotifyEventFieldCallback</a> into a
--   <a>C_WidgetClassPropertyNotifyEventFieldCallback</a>.
wrap_WidgetClassPropertyNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassPropertyNotifyEventFieldCallback)) -> WidgetClassPropertyNotifyEventFieldCallback -> C_WidgetClassPropertyNotifyEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassPopupMenuFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassPopupMenuFieldCallback -> a -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassPopupMenuFieldCallback</a></tt>.
noWidgetClassPopupMenuFieldCallback :: Maybe WidgetClassPopupMenuFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassPopupMenuFieldCallback :: MonadIO m => WidgetClassPopupMenuFieldCallback -> m (GClosure C_WidgetClassPopupMenuFieldCallback)

-- | Wrap a <a>WidgetClassPopupMenuFieldCallback</a> into a
--   <a>C_WidgetClassPopupMenuFieldCallback</a>.
wrap_WidgetClassPopupMenuFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassPopupMenuFieldCallback)) -> WidgetClassPopupMenuFieldCallback -> C_WidgetClassPopupMenuFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassParentSetFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => FunPtr C_WidgetClassParentSetFieldCallback -> a -> b -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassParentSetFieldCallback</a></tt>.
noWidgetClassParentSetFieldCallback :: Maybe WidgetClassParentSetFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassParentSetFieldCallback :: MonadIO m => WidgetClassParentSetFieldCallback -> m (GClosure C_WidgetClassParentSetFieldCallback)

-- | Wrap a <a>WidgetClassParentSetFieldCallback</a> into a
--   <a>C_WidgetClassParentSetFieldCallback</a>.
wrap_WidgetClassParentSetFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassParentSetFieldCallback)) -> WidgetClassParentSetFieldCallback -> C_WidgetClassParentSetFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassMoveFocusFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMoveFocusFieldCallback -> a -> DirectionType -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassMoveFocusFieldCallback</a></tt>.
noWidgetClassMoveFocusFieldCallback :: Maybe WidgetClassMoveFocusFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassMoveFocusFieldCallback :: MonadIO m => WidgetClassMoveFocusFieldCallback -> m (GClosure C_WidgetClassMoveFocusFieldCallback)

-- | Wrap a <a>WidgetClassMoveFocusFieldCallback</a> into a
--   <a>C_WidgetClassMoveFocusFieldCallback</a>.
wrap_WidgetClassMoveFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMoveFocusFieldCallback)) -> WidgetClassMoveFocusFieldCallback -> C_WidgetClassMoveFocusFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassMotionNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMotionNotifyEventFieldCallback -> a -> EventMotion -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassMotionNotifyEventFieldCallback</a></tt>.
noWidgetClassMotionNotifyEventFieldCallback :: Maybe WidgetClassMotionNotifyEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassMotionNotifyEventFieldCallback :: MonadIO m => WidgetClassMotionNotifyEventFieldCallback -> m (GClosure C_WidgetClassMotionNotifyEventFieldCallback)

-- | Wrap a <a>WidgetClassMotionNotifyEventFieldCallback</a> into a
--   <a>C_WidgetClassMotionNotifyEventFieldCallback</a>.
wrap_WidgetClassMotionNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMotionNotifyEventFieldCallback)) -> WidgetClassMotionNotifyEventFieldCallback -> C_WidgetClassMotionNotifyEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassMnemonicActivateFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMnemonicActivateFieldCallback -> a -> Bool -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassMnemonicActivateFieldCallback</a></tt>.
noWidgetClassMnemonicActivateFieldCallback :: Maybe WidgetClassMnemonicActivateFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassMnemonicActivateFieldCallback :: MonadIO m => WidgetClassMnemonicActivateFieldCallback -> m (GClosure C_WidgetClassMnemonicActivateFieldCallback)

-- | Wrap a <a>WidgetClassMnemonicActivateFieldCallback</a> into a
--   <a>C_WidgetClassMnemonicActivateFieldCallback</a>.
wrap_WidgetClassMnemonicActivateFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)) -> WidgetClassMnemonicActivateFieldCallback -> C_WidgetClassMnemonicActivateFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassMapFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMapFieldCallback -> a -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassMapFieldCallback</a></tt>.
noWidgetClassMapFieldCallback :: Maybe WidgetClassMapFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassMapFieldCallback :: MonadIO m => WidgetClassMapFieldCallback -> m (GClosure C_WidgetClassMapFieldCallback)

-- | Wrap a <a>WidgetClassMapFieldCallback</a> into a
--   <a>C_WidgetClassMapFieldCallback</a>.
wrap_WidgetClassMapFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMapFieldCallback)) -> WidgetClassMapFieldCallback -> C_WidgetClassMapFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassMapEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMapEventFieldCallback -> a -> EventAny -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassMapEventFieldCallback</a></tt>.
noWidgetClassMapEventFieldCallback :: Maybe WidgetClassMapEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassMapEventFieldCallback :: MonadIO m => WidgetClassMapEventFieldCallback -> m (GClosure C_WidgetClassMapEventFieldCallback)

-- | Wrap a <a>WidgetClassMapEventFieldCallback</a> into a
--   <a>C_WidgetClassMapEventFieldCallback</a>.
wrap_WidgetClassMapEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMapEventFieldCallback)) -> WidgetClassMapEventFieldCallback -> C_WidgetClassMapEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassLeaveNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassLeaveNotifyEventFieldCallback -> a -> EventCrossing -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassLeaveNotifyEventFieldCallback</a></tt>.
noWidgetClassLeaveNotifyEventFieldCallback :: Maybe WidgetClassLeaveNotifyEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassLeaveNotifyEventFieldCallback :: MonadIO m => WidgetClassLeaveNotifyEventFieldCallback -> m (GClosure C_WidgetClassLeaveNotifyEventFieldCallback)

-- | Wrap a <a>WidgetClassLeaveNotifyEventFieldCallback</a> into a
--   <a>C_WidgetClassLeaveNotifyEventFieldCallback</a>.
wrap_WidgetClassLeaveNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassLeaveNotifyEventFieldCallback)) -> WidgetClassLeaveNotifyEventFieldCallback -> C_WidgetClassLeaveNotifyEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassKeynavFailedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassKeynavFailedFieldCallback -> a -> DirectionType -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassKeynavFailedFieldCallback</a></tt>.
noWidgetClassKeynavFailedFieldCallback :: Maybe WidgetClassKeynavFailedFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassKeynavFailedFieldCallback :: MonadIO m => WidgetClassKeynavFailedFieldCallback -> m (GClosure C_WidgetClassKeynavFailedFieldCallback)

-- | Wrap a <a>WidgetClassKeynavFailedFieldCallback</a> into a
--   <a>C_WidgetClassKeynavFailedFieldCallback</a>.
wrap_WidgetClassKeynavFailedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassKeynavFailedFieldCallback)) -> WidgetClassKeynavFailedFieldCallback -> C_WidgetClassKeynavFailedFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassKeyReleaseEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassKeyReleaseEventFieldCallback -> a -> EventKey -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassKeyReleaseEventFieldCallback</a></tt>.
noWidgetClassKeyReleaseEventFieldCallback :: Maybe WidgetClassKeyReleaseEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassKeyReleaseEventFieldCallback :: MonadIO m => WidgetClassKeyReleaseEventFieldCallback -> m (GClosure C_WidgetClassKeyReleaseEventFieldCallback)

-- | Wrap a <a>WidgetClassKeyReleaseEventFieldCallback</a> into a
--   <a>C_WidgetClassKeyReleaseEventFieldCallback</a>.
wrap_WidgetClassKeyReleaseEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassKeyReleaseEventFieldCallback)) -> WidgetClassKeyReleaseEventFieldCallback -> C_WidgetClassKeyReleaseEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassKeyPressEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassKeyPressEventFieldCallback -> a -> EventKey -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassKeyPressEventFieldCallback</a></tt>.
noWidgetClassKeyPressEventFieldCallback :: Maybe WidgetClassKeyPressEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassKeyPressEventFieldCallback :: MonadIO m => WidgetClassKeyPressEventFieldCallback -> m (GClosure C_WidgetClassKeyPressEventFieldCallback)

-- | Wrap a <a>WidgetClassKeyPressEventFieldCallback</a> into a
--   <a>C_WidgetClassKeyPressEventFieldCallback</a>.
wrap_WidgetClassKeyPressEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassKeyPressEventFieldCallback)) -> WidgetClassKeyPressEventFieldCallback -> C_WidgetClassKeyPressEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassHierarchyChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => FunPtr C_WidgetClassHierarchyChangedFieldCallback -> a -> b -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassHierarchyChangedFieldCallback</a></tt>.
noWidgetClassHierarchyChangedFieldCallback :: Maybe WidgetClassHierarchyChangedFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassHierarchyChangedFieldCallback :: MonadIO m => WidgetClassHierarchyChangedFieldCallback -> m (GClosure C_WidgetClassHierarchyChangedFieldCallback)

-- | Wrap a <a>WidgetClassHierarchyChangedFieldCallback</a> into a
--   <a>C_WidgetClassHierarchyChangedFieldCallback</a>.
wrap_WidgetClassHierarchyChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassHierarchyChangedFieldCallback)) -> WidgetClassHierarchyChangedFieldCallback -> C_WidgetClassHierarchyChangedFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassHideFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassHideFieldCallback -> a -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassHideFieldCallback</a></tt>.
noWidgetClassHideFieldCallback :: Maybe WidgetClassHideFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassHideFieldCallback :: MonadIO m => WidgetClassHideFieldCallback -> m (GClosure C_WidgetClassHideFieldCallback)

-- | Wrap a <a>WidgetClassHideFieldCallback</a> into a
--   <a>C_WidgetClassHideFieldCallback</a>.
wrap_WidgetClassHideFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassHideFieldCallback)) -> WidgetClassHideFieldCallback -> C_WidgetClassHideFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassGrabNotifyFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGrabNotifyFieldCallback -> a -> Bool -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassGrabNotifyFieldCallback</a></tt>.
noWidgetClassGrabNotifyFieldCallback :: Maybe WidgetClassGrabNotifyFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassGrabNotifyFieldCallback :: MonadIO m => WidgetClassGrabNotifyFieldCallback -> m (GClosure C_WidgetClassGrabNotifyFieldCallback)

-- | Wrap a <a>WidgetClassGrabNotifyFieldCallback</a> into a
--   <a>C_WidgetClassGrabNotifyFieldCallback</a>.
wrap_WidgetClassGrabNotifyFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGrabNotifyFieldCallback)) -> WidgetClassGrabNotifyFieldCallback -> C_WidgetClassGrabNotifyFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassGrabFocusFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGrabFocusFieldCallback -> a -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassGrabFocusFieldCallback</a></tt>.
noWidgetClassGrabFocusFieldCallback :: Maybe WidgetClassGrabFocusFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassGrabFocusFieldCallback :: MonadIO m => WidgetClassGrabFocusFieldCallback -> m (GClosure C_WidgetClassGrabFocusFieldCallback)

-- | Wrap a <a>WidgetClassGrabFocusFieldCallback</a> into a
--   <a>C_WidgetClassGrabFocusFieldCallback</a>.
wrap_WidgetClassGrabFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)) -> WidgetClassGrabFocusFieldCallback -> C_WidgetClassGrabFocusFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassGrabBrokenEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGrabBrokenEventFieldCallback -> a -> EventGrabBroken -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassGrabBrokenEventFieldCallback</a></tt>.
noWidgetClassGrabBrokenEventFieldCallback :: Maybe WidgetClassGrabBrokenEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassGrabBrokenEventFieldCallback :: MonadIO m => WidgetClassGrabBrokenEventFieldCallback -> m (GClosure C_WidgetClassGrabBrokenEventFieldCallback)

-- | Wrap a <a>WidgetClassGrabBrokenEventFieldCallback</a> into a
--   <a>C_WidgetClassGrabBrokenEventFieldCallback</a>.
wrap_WidgetClassGrabBrokenEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGrabBrokenEventFieldCallback)) -> WidgetClassGrabBrokenEventFieldCallback -> C_WidgetClassGrabBrokenEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassGetRequestModeFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGetRequestModeFieldCallback -> a -> m SizeRequestMode

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassGetRequestModeFieldCallback</a></tt>.
noWidgetClassGetRequestModeFieldCallback :: Maybe WidgetClassGetRequestModeFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassGetRequestModeFieldCallback :: MonadIO m => WidgetClassGetRequestModeFieldCallback -> m (GClosure C_WidgetClassGetRequestModeFieldCallback)

-- | Wrap a <a>WidgetClassGetRequestModeFieldCallback</a> into a
--   <a>C_WidgetClassGetRequestModeFieldCallback</a>.
wrap_WidgetClassGetRequestModeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)) -> WidgetClassGetRequestModeFieldCallback -> C_WidgetClassGetRequestModeFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassGetPreferredWidthForHeightFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback -> a -> Int32 -> m (Int32, Int32)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassGetPreferredWidthForHeightFieldCallback</a></tt>.
noWidgetClassGetPreferredWidthForHeightFieldCallback :: Maybe WidgetClassGetPreferredWidthForHeightFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassGetPreferredWidthForHeightFieldCallback :: MonadIO m => WidgetClassGetPreferredWidthForHeightFieldCallback -> m (GClosure C_WidgetClassGetPreferredWidthForHeightFieldCallback)

-- | Wrap a <a>WidgetClassGetPreferredWidthForHeightFieldCallback</a> into
--   a <a>C_WidgetClassGetPreferredWidthForHeightFieldCallback</a>.
wrap_WidgetClassGetPreferredWidthForHeightFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback)) -> WidgetClassGetPreferredWidthForHeightFieldCallback -> C_WidgetClassGetPreferredWidthForHeightFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassGetPreferredWidthFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGetPreferredWidthFieldCallback -> a -> m (Int32, Int32)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassGetPreferredWidthFieldCallback</a></tt>.
noWidgetClassGetPreferredWidthFieldCallback :: Maybe WidgetClassGetPreferredWidthFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassGetPreferredWidthFieldCallback :: MonadIO m => WidgetClassGetPreferredWidthFieldCallback -> m (GClosure C_WidgetClassGetPreferredWidthFieldCallback)

-- | Wrap a <a>WidgetClassGetPreferredWidthFieldCallback</a> into a
--   <a>C_WidgetClassGetPreferredWidthFieldCallback</a>.
wrap_WidgetClassGetPreferredWidthFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredWidthFieldCallback)) -> WidgetClassGetPreferredWidthFieldCallback -> C_WidgetClassGetPreferredWidthFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassGetPreferredHeightForWidthFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGetPreferredHeightForWidthFieldCallback -> a -> Int32 -> m (Int32, Int32)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassGetPreferredHeightForWidthFieldCallback</a></tt>.
noWidgetClassGetPreferredHeightForWidthFieldCallback :: Maybe WidgetClassGetPreferredHeightForWidthFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassGetPreferredHeightForWidthFieldCallback :: MonadIO m => WidgetClassGetPreferredHeightForWidthFieldCallback -> m (GClosure C_WidgetClassGetPreferredHeightForWidthFieldCallback)

-- | Wrap a <a>WidgetClassGetPreferredHeightForWidthFieldCallback</a> into
--   a <a>C_WidgetClassGetPreferredHeightForWidthFieldCallback</a>.
wrap_WidgetClassGetPreferredHeightForWidthFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredHeightForWidthFieldCallback)) -> WidgetClassGetPreferredHeightForWidthFieldCallback -> C_WidgetClassGetPreferredHeightForWidthFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassGetPreferredHeightFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGetPreferredHeightFieldCallback -> a -> m (Int32, Int32)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassGetPreferredHeightFieldCallback</a></tt>.
noWidgetClassGetPreferredHeightFieldCallback :: Maybe WidgetClassGetPreferredHeightFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassGetPreferredHeightFieldCallback :: MonadIO m => WidgetClassGetPreferredHeightFieldCallback -> m (GClosure C_WidgetClassGetPreferredHeightFieldCallback)

-- | Wrap a <a>WidgetClassGetPreferredHeightFieldCallback</a> into a
--   <a>C_WidgetClassGetPreferredHeightFieldCallback</a>.
wrap_WidgetClassGetPreferredHeightFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredHeightFieldCallback)) -> WidgetClassGetPreferredHeightFieldCallback -> C_WidgetClassGetPreferredHeightFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> a -> Int32 -> m (Int32, Int32, Int32, Int32)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback</a></tt>.
noWidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: Maybe WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: MonadIO m => WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> m (GClosure C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)

-- | Wrap a
--   <a>WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback</a>
--   into a
--   <a>C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback</a>.
wrap_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)) -> WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassGetAccessibleFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGetAccessibleFieldCallback -> a -> m Object

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassGetAccessibleFieldCallback</a></tt>.
noWidgetClassGetAccessibleFieldCallback :: Maybe WidgetClassGetAccessibleFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassGetAccessibleFieldCallback :: MonadIO m => WidgetClassGetAccessibleFieldCallback -> m (GClosure C_WidgetClassGetAccessibleFieldCallback)

-- | Wrap a <a>WidgetClassGetAccessibleFieldCallback</a> into a
--   <a>C_WidgetClassGetAccessibleFieldCallback</a>.
wrap_WidgetClassGetAccessibleFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetAccessibleFieldCallback)) -> WidgetClassGetAccessibleFieldCallback -> C_WidgetClassGetAccessibleFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassFocusOutEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassFocusOutEventFieldCallback -> a -> EventFocus -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassFocusOutEventFieldCallback</a></tt>.
noWidgetClassFocusOutEventFieldCallback :: Maybe WidgetClassFocusOutEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassFocusOutEventFieldCallback :: MonadIO m => WidgetClassFocusOutEventFieldCallback -> m (GClosure C_WidgetClassFocusOutEventFieldCallback)

-- | Wrap a <a>WidgetClassFocusOutEventFieldCallback</a> into a
--   <a>C_WidgetClassFocusOutEventFieldCallback</a>.
wrap_WidgetClassFocusOutEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassFocusOutEventFieldCallback)) -> WidgetClassFocusOutEventFieldCallback -> C_WidgetClassFocusOutEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassFocusInEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassFocusInEventFieldCallback -> a -> EventFocus -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassFocusInEventFieldCallback</a></tt>.
noWidgetClassFocusInEventFieldCallback :: Maybe WidgetClassFocusInEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassFocusInEventFieldCallback :: MonadIO m => WidgetClassFocusInEventFieldCallback -> m (GClosure C_WidgetClassFocusInEventFieldCallback)

-- | Wrap a <a>WidgetClassFocusInEventFieldCallback</a> into a
--   <a>C_WidgetClassFocusInEventFieldCallback</a>.
wrap_WidgetClassFocusInEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassFocusInEventFieldCallback)) -> WidgetClassFocusInEventFieldCallback -> C_WidgetClassFocusInEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassFocusFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassFocusFieldCallback -> a -> DirectionType -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassFocusFieldCallback</a></tt>.
noWidgetClassFocusFieldCallback :: Maybe WidgetClassFocusFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassFocusFieldCallback :: MonadIO m => WidgetClassFocusFieldCallback -> m (GClosure C_WidgetClassFocusFieldCallback)

-- | Wrap a <a>WidgetClassFocusFieldCallback</a> into a
--   <a>C_WidgetClassFocusFieldCallback</a>.
wrap_WidgetClassFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassFocusFieldCallback)) -> WidgetClassFocusFieldCallback -> C_WidgetClassFocusFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassEventFieldCallback -> a -> Event -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassEventFieldCallback</a></tt>.
noWidgetClassEventFieldCallback :: Maybe WidgetClassEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassEventFieldCallback :: MonadIO m => WidgetClassEventFieldCallback -> m (GClosure C_WidgetClassEventFieldCallback)

-- | Wrap a <a>WidgetClassEventFieldCallback</a> into a
--   <a>C_WidgetClassEventFieldCallback</a>.
wrap_WidgetClassEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassEventFieldCallback)) -> WidgetClassEventFieldCallback -> C_WidgetClassEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassEnterNotifyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassEnterNotifyEventFieldCallback -> a -> EventCrossing -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassEnterNotifyEventFieldCallback</a></tt>.
noWidgetClassEnterNotifyEventFieldCallback :: Maybe WidgetClassEnterNotifyEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassEnterNotifyEventFieldCallback :: MonadIO m => WidgetClassEnterNotifyEventFieldCallback -> m (GClosure C_WidgetClassEnterNotifyEventFieldCallback)

-- | Wrap a <a>WidgetClassEnterNotifyEventFieldCallback</a> into a
--   <a>C_WidgetClassEnterNotifyEventFieldCallback</a>.
wrap_WidgetClassEnterNotifyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassEnterNotifyEventFieldCallback)) -> WidgetClassEnterNotifyEventFieldCallback -> C_WidgetClassEnterNotifyEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDrawFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDrawFieldCallback -> a -> Context -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDrawFieldCallback</a></tt>.
noWidgetClassDrawFieldCallback :: Maybe WidgetClassDrawFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDrawFieldCallback :: MonadIO m => WidgetClassDrawFieldCallback -> m (GClosure C_WidgetClassDrawFieldCallback)

-- | Wrap a <a>WidgetClassDrawFieldCallback</a> into a
--   <a>C_WidgetClassDrawFieldCallback</a>.
wrap_WidgetClassDrawFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDrawFieldCallback)) -> WidgetClassDrawFieldCallback -> C_WidgetClassDrawFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDragMotionFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragMotionFieldCallback -> a -> b -> Int32 -> Int32 -> Word32 -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDragMotionFieldCallback</a></tt>.
noWidgetClassDragMotionFieldCallback :: Maybe WidgetClassDragMotionFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDragMotionFieldCallback :: MonadIO m => WidgetClassDragMotionFieldCallback -> m (GClosure C_WidgetClassDragMotionFieldCallback)

-- | Wrap a <a>WidgetClassDragMotionFieldCallback</a> into a
--   <a>C_WidgetClassDragMotionFieldCallback</a>.
wrap_WidgetClassDragMotionFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragMotionFieldCallback)) -> WidgetClassDragMotionFieldCallback -> C_WidgetClassDragMotionFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDragLeaveFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragLeaveFieldCallback -> a -> b -> Word32 -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDragLeaveFieldCallback</a></tt>.
noWidgetClassDragLeaveFieldCallback :: Maybe WidgetClassDragLeaveFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDragLeaveFieldCallback :: MonadIO m => WidgetClassDragLeaveFieldCallback -> m (GClosure C_WidgetClassDragLeaveFieldCallback)

-- | Wrap a <a>WidgetClassDragLeaveFieldCallback</a> into a
--   <a>C_WidgetClassDragLeaveFieldCallback</a>.
wrap_WidgetClassDragLeaveFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragLeaveFieldCallback)) -> WidgetClassDragLeaveFieldCallback -> C_WidgetClassDragLeaveFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDragFailedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragFailedFieldCallback -> a -> b -> DragResult -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDragFailedFieldCallback</a></tt>.
noWidgetClassDragFailedFieldCallback :: Maybe WidgetClassDragFailedFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDragFailedFieldCallback :: MonadIO m => WidgetClassDragFailedFieldCallback -> m (GClosure C_WidgetClassDragFailedFieldCallback)

-- | Wrap a <a>WidgetClassDragFailedFieldCallback</a> into a
--   <a>C_WidgetClassDragFailedFieldCallback</a>.
wrap_WidgetClassDragFailedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragFailedFieldCallback)) -> WidgetClassDragFailedFieldCallback -> C_WidgetClassDragFailedFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDragEndFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragEndFieldCallback -> a -> b -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDragEndFieldCallback</a></tt>.
noWidgetClassDragEndFieldCallback :: Maybe WidgetClassDragEndFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDragEndFieldCallback :: MonadIO m => WidgetClassDragEndFieldCallback -> m (GClosure C_WidgetClassDragEndFieldCallback)

-- | Wrap a <a>WidgetClassDragEndFieldCallback</a> into a
--   <a>C_WidgetClassDragEndFieldCallback</a>.
wrap_WidgetClassDragEndFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragEndFieldCallback)) -> WidgetClassDragEndFieldCallback -> C_WidgetClassDragEndFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDragDropFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragDropFieldCallback -> a -> b -> Int32 -> Int32 -> Word32 -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDragDropFieldCallback</a></tt>.
noWidgetClassDragDropFieldCallback :: Maybe WidgetClassDragDropFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDragDropFieldCallback :: MonadIO m => WidgetClassDragDropFieldCallback -> m (GClosure C_WidgetClassDragDropFieldCallback)

-- | Wrap a <a>WidgetClassDragDropFieldCallback</a> into a
--   <a>C_WidgetClassDragDropFieldCallback</a>.
wrap_WidgetClassDragDropFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragDropFieldCallback)) -> WidgetClassDragDropFieldCallback -> C_WidgetClassDragDropFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDragDataReceivedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragDataReceivedFieldCallback -> a -> b -> Int32 -> Int32 -> SelectionData -> Word32 -> Word32 -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDragDataReceivedFieldCallback</a></tt>.
noWidgetClassDragDataReceivedFieldCallback :: Maybe WidgetClassDragDataReceivedFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDragDataReceivedFieldCallback :: MonadIO m => WidgetClassDragDataReceivedFieldCallback -> m (GClosure C_WidgetClassDragDataReceivedFieldCallback)

-- | Wrap a <a>WidgetClassDragDataReceivedFieldCallback</a> into a
--   <a>C_WidgetClassDragDataReceivedFieldCallback</a>.
wrap_WidgetClassDragDataReceivedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragDataReceivedFieldCallback)) -> WidgetClassDragDataReceivedFieldCallback -> C_WidgetClassDragDataReceivedFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDragDataGetFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragDataGetFieldCallback -> a -> b -> SelectionData -> Word32 -> Word32 -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDragDataGetFieldCallback</a></tt>.
noWidgetClassDragDataGetFieldCallback :: Maybe WidgetClassDragDataGetFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDragDataGetFieldCallback :: MonadIO m => WidgetClassDragDataGetFieldCallback -> m (GClosure C_WidgetClassDragDataGetFieldCallback)

-- | Wrap a <a>WidgetClassDragDataGetFieldCallback</a> into a
--   <a>C_WidgetClassDragDataGetFieldCallback</a>.
wrap_WidgetClassDragDataGetFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragDataGetFieldCallback)) -> WidgetClassDragDataGetFieldCallback -> C_WidgetClassDragDataGetFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDragDataDeleteFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragDataDeleteFieldCallback -> a -> b -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDragDataDeleteFieldCallback</a></tt>.
noWidgetClassDragDataDeleteFieldCallback :: Maybe WidgetClassDragDataDeleteFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDragDataDeleteFieldCallback :: MonadIO m => WidgetClassDragDataDeleteFieldCallback -> m (GClosure C_WidgetClassDragDataDeleteFieldCallback)

-- | Wrap a <a>WidgetClassDragDataDeleteFieldCallback</a> into a
--   <a>C_WidgetClassDragDataDeleteFieldCallback</a>.
wrap_WidgetClassDragDataDeleteFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragDataDeleteFieldCallback)) -> WidgetClassDragDataDeleteFieldCallback -> C_WidgetClassDragDataDeleteFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDragBeginFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => FunPtr C_WidgetClassDragBeginFieldCallback -> a -> b -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDragBeginFieldCallback</a></tt>.
noWidgetClassDragBeginFieldCallback :: Maybe WidgetClassDragBeginFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDragBeginFieldCallback :: MonadIO m => WidgetClassDragBeginFieldCallback -> m (GClosure C_WidgetClassDragBeginFieldCallback)

-- | Wrap a <a>WidgetClassDragBeginFieldCallback</a> into a
--   <a>C_WidgetClassDragBeginFieldCallback</a>.
wrap_WidgetClassDragBeginFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)) -> WidgetClassDragBeginFieldCallback -> C_WidgetClassDragBeginFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDispatchChildPropertiesChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback -> a -> Word32 -> GParamSpec -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDispatchChildPropertiesChangedFieldCallback</a></tt>.
noWidgetClassDispatchChildPropertiesChangedFieldCallback :: Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDispatchChildPropertiesChangedFieldCallback :: MonadIO m => WidgetClassDispatchChildPropertiesChangedFieldCallback -> m (GClosure C_WidgetClassDispatchChildPropertiesChangedFieldCallback)

-- | Wrap a <a>WidgetClassDispatchChildPropertiesChangedFieldCallback</a>
--   into a
--   <a>C_WidgetClassDispatchChildPropertiesChangedFieldCallback</a>.
wrap_WidgetClassDispatchChildPropertiesChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback)) -> WidgetClassDispatchChildPropertiesChangedFieldCallback -> C_WidgetClassDispatchChildPropertiesChangedFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDirectionChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDirectionChangedFieldCallback -> a -> TextDirection -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDirectionChangedFieldCallback</a></tt>.
noWidgetClassDirectionChangedFieldCallback :: Maybe WidgetClassDirectionChangedFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDirectionChangedFieldCallback :: MonadIO m => WidgetClassDirectionChangedFieldCallback -> m (GClosure C_WidgetClassDirectionChangedFieldCallback)

-- | Wrap a <a>WidgetClassDirectionChangedFieldCallback</a> into a
--   <a>C_WidgetClassDirectionChangedFieldCallback</a>.
wrap_WidgetClassDirectionChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDirectionChangedFieldCallback)) -> WidgetClassDirectionChangedFieldCallback -> C_WidgetClassDirectionChangedFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDestroyFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDestroyFieldCallback</a></tt>.
noWidgetClassDestroyFieldCallback :: Maybe WidgetClassDestroyFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDestroyFieldCallback :: MonadIO m => WidgetClassDestroyFieldCallback -> m (GClosure C_WidgetClassDestroyFieldCallback)

-- | Wrap a <a>WidgetClassDestroyFieldCallback</a> into a
--   <a>C_WidgetClassDestroyFieldCallback</a>.
wrap_WidgetClassDestroyFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDestroyFieldCallback)) -> WidgetClassDestroyFieldCallback -> C_WidgetClassDestroyFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDestroyEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDestroyEventFieldCallback -> a -> EventAny -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDestroyEventFieldCallback</a></tt>.
noWidgetClassDestroyEventFieldCallback :: Maybe WidgetClassDestroyEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDestroyEventFieldCallback :: MonadIO m => WidgetClassDestroyEventFieldCallback -> m (GClosure C_WidgetClassDestroyEventFieldCallback)

-- | Wrap a <a>WidgetClassDestroyEventFieldCallback</a> into a
--   <a>C_WidgetClassDestroyEventFieldCallback</a>.
wrap_WidgetClassDestroyEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDestroyEventFieldCallback)) -> WidgetClassDestroyEventFieldCallback -> C_WidgetClassDestroyEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDeleteEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDeleteEventFieldCallback -> a -> EventAny -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDeleteEventFieldCallback</a></tt>.
noWidgetClassDeleteEventFieldCallback :: Maybe WidgetClassDeleteEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDeleteEventFieldCallback :: MonadIO m => WidgetClassDeleteEventFieldCallback -> m (GClosure C_WidgetClassDeleteEventFieldCallback)

-- | Wrap a <a>WidgetClassDeleteEventFieldCallback</a> into a
--   <a>C_WidgetClassDeleteEventFieldCallback</a>.
wrap_WidgetClassDeleteEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDeleteEventFieldCallback)) -> WidgetClassDeleteEventFieldCallback -> C_WidgetClassDeleteEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDamageEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDamageEventFieldCallback -> a -> EventExpose -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDamageEventFieldCallback</a></tt>.
noWidgetClassDamageEventFieldCallback :: Maybe WidgetClassDamageEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDamageEventFieldCallback :: MonadIO m => WidgetClassDamageEventFieldCallback -> m (GClosure C_WidgetClassDamageEventFieldCallback)

-- | Wrap a <a>WidgetClassDamageEventFieldCallback</a> into a
--   <a>C_WidgetClassDamageEventFieldCallback</a>.
wrap_WidgetClassDamageEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDamageEventFieldCallback)) -> WidgetClassDamageEventFieldCallback -> C_WidgetClassDamageEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassConfigureEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassConfigureEventFieldCallback -> a -> EventConfigure -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassConfigureEventFieldCallback</a></tt>.
noWidgetClassConfigureEventFieldCallback :: Maybe WidgetClassConfigureEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassConfigureEventFieldCallback :: MonadIO m => WidgetClassConfigureEventFieldCallback -> m (GClosure C_WidgetClassConfigureEventFieldCallback)

-- | Wrap a <a>WidgetClassConfigureEventFieldCallback</a> into a
--   <a>C_WidgetClassConfigureEventFieldCallback</a>.
wrap_WidgetClassConfigureEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassConfigureEventFieldCallback)) -> WidgetClassConfigureEventFieldCallback -> C_WidgetClassConfigureEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassComputeExpandFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassComputeExpandFieldCallback -> a -> Bool -> Bool -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassComputeExpandFieldCallback</a></tt>.
noWidgetClassComputeExpandFieldCallback :: Maybe WidgetClassComputeExpandFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassComputeExpandFieldCallback :: MonadIO m => WidgetClassComputeExpandFieldCallback -> m (GClosure C_WidgetClassComputeExpandFieldCallback)

-- | Wrap a <a>WidgetClassComputeExpandFieldCallback</a> into a
--   <a>C_WidgetClassComputeExpandFieldCallback</a>.
wrap_WidgetClassComputeExpandFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)) -> WidgetClassComputeExpandFieldCallback -> C_WidgetClassComputeExpandFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassCompositedChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassCompositedChangedFieldCallback -> a -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassCompositedChangedFieldCallback</a></tt>.
noWidgetClassCompositedChangedFieldCallback :: Maybe WidgetClassCompositedChangedFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassCompositedChangedFieldCallback :: MonadIO m => WidgetClassCompositedChangedFieldCallback -> m (GClosure C_WidgetClassCompositedChangedFieldCallback)

-- | Wrap a <a>WidgetClassCompositedChangedFieldCallback</a> into a
--   <a>C_WidgetClassCompositedChangedFieldCallback</a>.
wrap_WidgetClassCompositedChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassCompositedChangedFieldCallback)) -> WidgetClassCompositedChangedFieldCallback -> C_WidgetClassCompositedChangedFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassChildNotifyFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassChildNotifyFieldCallback -> a -> GParamSpec -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassChildNotifyFieldCallback</a></tt>.
noWidgetClassChildNotifyFieldCallback :: Maybe WidgetClassChildNotifyFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassChildNotifyFieldCallback :: MonadIO m => WidgetClassChildNotifyFieldCallback -> m (GClosure C_WidgetClassChildNotifyFieldCallback)

-- | Wrap a <a>WidgetClassChildNotifyFieldCallback</a> into a
--   <a>C_WidgetClassChildNotifyFieldCallback</a>.
wrap_WidgetClassChildNotifyFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassChildNotifyFieldCallback)) -> WidgetClassChildNotifyFieldCallback -> C_WidgetClassChildNotifyFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassCanActivateAccelFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassCanActivateAccelFieldCallback -> a -> Word32 -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassCanActivateAccelFieldCallback</a></tt>.
noWidgetClassCanActivateAccelFieldCallback :: Maybe WidgetClassCanActivateAccelFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassCanActivateAccelFieldCallback :: MonadIO m => WidgetClassCanActivateAccelFieldCallback -> m (GClosure C_WidgetClassCanActivateAccelFieldCallback)

-- | Wrap a <a>WidgetClassCanActivateAccelFieldCallback</a> into a
--   <a>C_WidgetClassCanActivateAccelFieldCallback</a>.
wrap_WidgetClassCanActivateAccelFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassCanActivateAccelFieldCallback)) -> WidgetClassCanActivateAccelFieldCallback -> C_WidgetClassCanActivateAccelFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassButtonReleaseEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassButtonReleaseEventFieldCallback -> a -> EventButton -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassButtonReleaseEventFieldCallback</a></tt>.
noWidgetClassButtonReleaseEventFieldCallback :: Maybe WidgetClassButtonReleaseEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassButtonReleaseEventFieldCallback :: MonadIO m => WidgetClassButtonReleaseEventFieldCallback -> m (GClosure C_WidgetClassButtonReleaseEventFieldCallback)

-- | Wrap a <a>WidgetClassButtonReleaseEventFieldCallback</a> into a
--   <a>C_WidgetClassButtonReleaseEventFieldCallback</a>.
wrap_WidgetClassButtonReleaseEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassButtonReleaseEventFieldCallback)) -> WidgetClassButtonReleaseEventFieldCallback -> C_WidgetClassButtonReleaseEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassButtonPressEventFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassButtonPressEventFieldCallback -> a -> EventButton -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassButtonPressEventFieldCallback</a></tt>.
noWidgetClassButtonPressEventFieldCallback :: Maybe WidgetClassButtonPressEventFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassButtonPressEventFieldCallback :: MonadIO m => WidgetClassButtonPressEventFieldCallback -> m (GClosure C_WidgetClassButtonPressEventFieldCallback)

-- | Wrap a <a>WidgetClassButtonPressEventFieldCallback</a> into a
--   <a>C_WidgetClassButtonPressEventFieldCallback</a>.
wrap_WidgetClassButtonPressEventFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassButtonPressEventFieldCallback)) -> WidgetClassButtonPressEventFieldCallback -> C_WidgetClassButtonPressEventFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassAdjustSizeRequestFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassAdjustSizeRequestFieldCallback -> a -> Orientation -> Int32 -> Int32 -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassAdjustSizeRequestFieldCallback</a></tt>.
noWidgetClassAdjustSizeRequestFieldCallback :: Maybe WidgetClassAdjustSizeRequestFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassAdjustSizeRequestFieldCallback :: MonadIO m => WidgetClassAdjustSizeRequestFieldCallback -> m (GClosure C_WidgetClassAdjustSizeRequestFieldCallback)

-- | Wrap a <a>WidgetClassAdjustSizeRequestFieldCallback</a> into a
--   <a>C_WidgetClassAdjustSizeRequestFieldCallback</a>.
wrap_WidgetClassAdjustSizeRequestFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassAdjustSizeRequestFieldCallback)) -> WidgetClassAdjustSizeRequestFieldCallback -> C_WidgetClassAdjustSizeRequestFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassAdjustSizeAllocationFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback -> a -> Orientation -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassAdjustSizeAllocationFieldCallback</a></tt>.
noWidgetClassAdjustSizeAllocationFieldCallback :: Maybe WidgetClassAdjustSizeAllocationFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassAdjustSizeAllocationFieldCallback :: MonadIO m => WidgetClassAdjustSizeAllocationFieldCallback -> m (GClosure C_WidgetClassAdjustSizeAllocationFieldCallback)

-- | Wrap a <a>WidgetClassAdjustSizeAllocationFieldCallback</a> into a
--   <a>C_WidgetClassAdjustSizeAllocationFieldCallback</a>.
wrap_WidgetClassAdjustSizeAllocationFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback)) -> WidgetClassAdjustSizeAllocationFieldCallback -> C_WidgetClassAdjustSizeAllocationFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassAdjustBaselineRequestFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback -> a -> Int32 -> Int32 -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassAdjustBaselineRequestFieldCallback</a></tt>.
noWidgetClassAdjustBaselineRequestFieldCallback :: Maybe WidgetClassAdjustBaselineRequestFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassAdjustBaselineRequestFieldCallback :: MonadIO m => WidgetClassAdjustBaselineRequestFieldCallback -> m (GClosure C_WidgetClassAdjustBaselineRequestFieldCallback)

-- | Wrap a <a>WidgetClassAdjustBaselineRequestFieldCallback</a> into a
--   <a>C_WidgetClassAdjustBaselineRequestFieldCallback</a>.
wrap_WidgetClassAdjustBaselineRequestFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback)) -> WidgetClassAdjustBaselineRequestFieldCallback -> C_WidgetClassAdjustBaselineRequestFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassAdjustBaselineAllocationFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback -> a -> Int32 -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassAdjustBaselineAllocationFieldCallback</a></tt>.
noWidgetClassAdjustBaselineAllocationFieldCallback :: Maybe WidgetClassAdjustBaselineAllocationFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassAdjustBaselineAllocationFieldCallback :: MonadIO m => WidgetClassAdjustBaselineAllocationFieldCallback -> m (GClosure C_WidgetClassAdjustBaselineAllocationFieldCallback)

-- | Wrap a <a>WidgetClassAdjustBaselineAllocationFieldCallback</a> into a
--   <a>C_WidgetClassAdjustBaselineAllocationFieldCallback</a>.
wrap_WidgetClassAdjustBaselineAllocationFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback)) -> WidgetClassAdjustBaselineAllocationFieldCallback -> C_WidgetClassAdjustBaselineAllocationFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeViewSearchPositionFunc :: (HasCallStack, MonadIO m, IsTreeView a, IsWidget b) => FunPtr C_TreeViewSearchPositionFunc -> a -> b -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewSearchPositionFunc</a></tt>.
noTreeViewSearchPositionFunc :: Maybe TreeViewSearchPositionFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewSearchPositionFunc_WithClosures</a></tt>.
noTreeViewSearchPositionFunc_WithClosures :: Maybe TreeViewSearchPositionFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeViewSearchPositionFunc :: TreeViewSearchPositionFunc -> TreeViewSearchPositionFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeViewSearchPositionFunc :: MonadIO m => TreeViewSearchPositionFunc -> m (GClosure C_TreeViewSearchPositionFunc)

-- | Wrap a <a>TreeViewSearchPositionFunc</a> into a
--   <a>C_TreeViewSearchPositionFunc</a>.
wrap_TreeViewSearchPositionFunc :: Maybe (Ptr (FunPtr C_TreeViewSearchPositionFunc)) -> TreeViewSearchPositionFunc_WithClosures -> C_TreeViewSearchPositionFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeViewSearchEqualFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeViewSearchEqualFunc -> a -> Int32 -> Text -> TreeIter -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewSearchEqualFunc</a></tt>.
noTreeViewSearchEqualFunc :: Maybe TreeViewSearchEqualFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewSearchEqualFunc_WithClosures</a></tt>.
noTreeViewSearchEqualFunc_WithClosures :: Maybe TreeViewSearchEqualFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeViewSearchEqualFunc :: TreeViewSearchEqualFunc -> TreeViewSearchEqualFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeViewSearchEqualFunc :: MonadIO m => TreeViewSearchEqualFunc -> m (GClosure C_TreeViewSearchEqualFunc)

-- | Wrap a <a>TreeViewSearchEqualFunc</a> into a
--   <a>C_TreeViewSearchEqualFunc</a>.
wrap_TreeViewSearchEqualFunc :: Maybe (Ptr (FunPtr C_TreeViewSearchEqualFunc)) -> TreeViewSearchEqualFunc_WithClosures -> C_TreeViewSearchEqualFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeViewRowSeparatorFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeViewRowSeparatorFunc -> a -> TreeIter -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewRowSeparatorFunc</a></tt>.
noTreeViewRowSeparatorFunc :: Maybe TreeViewRowSeparatorFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewRowSeparatorFunc_WithClosures</a></tt>.
noTreeViewRowSeparatorFunc_WithClosures :: Maybe TreeViewRowSeparatorFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeViewRowSeparatorFunc :: TreeViewRowSeparatorFunc -> TreeViewRowSeparatorFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeViewRowSeparatorFunc :: MonadIO m => TreeViewRowSeparatorFunc -> m (GClosure C_TreeViewRowSeparatorFunc)

-- | Wrap a <a>TreeViewRowSeparatorFunc</a> into a
--   <a>C_TreeViewRowSeparatorFunc</a>.
wrap_TreeViewRowSeparatorFunc :: Maybe (Ptr (FunPtr C_TreeViewRowSeparatorFunc)) -> TreeViewRowSeparatorFunc_WithClosures -> C_TreeViewRowSeparatorFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeViewMappingFunc :: (HasCallStack, MonadIO m, IsTreeView a) => FunPtr C_TreeViewMappingFunc -> a -> TreePath -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewMappingFunc</a></tt>.
noTreeViewMappingFunc :: Maybe TreeViewMappingFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewMappingFunc_WithClosures</a></tt>.
noTreeViewMappingFunc_WithClosures :: Maybe TreeViewMappingFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeViewMappingFunc :: TreeViewMappingFunc -> TreeViewMappingFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeViewMappingFunc :: MonadIO m => TreeViewMappingFunc -> m (GClosure C_TreeViewMappingFunc)

-- | Wrap a <a>TreeViewMappingFunc</a> into a <a>C_TreeViewMappingFunc</a>.
wrap_TreeViewMappingFunc :: Maybe (Ptr (FunPtr C_TreeViewMappingFunc)) -> TreeViewMappingFunc_WithClosures -> C_TreeViewMappingFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeViewColumnDropFunc :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsTreeViewColumn c, IsTreeViewColumn d) => FunPtr C_TreeViewColumnDropFunc -> a -> b -> c -> d -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewColumnDropFunc</a></tt>.
noTreeViewColumnDropFunc :: Maybe TreeViewColumnDropFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewColumnDropFunc_WithClosures</a></tt>.
noTreeViewColumnDropFunc_WithClosures :: Maybe TreeViewColumnDropFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeViewColumnDropFunc :: TreeViewColumnDropFunc -> TreeViewColumnDropFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeViewColumnDropFunc :: MonadIO m => TreeViewColumnDropFunc -> m (GClosure C_TreeViewColumnDropFunc)

-- | Wrap a <a>TreeViewColumnDropFunc</a> into a
--   <a>C_TreeViewColumnDropFunc</a>.
wrap_TreeViewColumnDropFunc :: Maybe (Ptr (FunPtr C_TreeViewColumnDropFunc)) -> TreeViewColumnDropFunc_WithClosures -> C_TreeViewColumnDropFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeSelectionFunc :: (HasCallStack, MonadIO m, IsTreeSelection a, IsTreeModel b) => FunPtr C_TreeSelectionFunc -> a -> b -> TreePath -> Bool -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeSelectionFunc</a></tt>.
noTreeSelectionFunc :: Maybe TreeSelectionFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeSelectionFunc_WithClosures</a></tt>.
noTreeSelectionFunc_WithClosures :: Maybe TreeSelectionFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeSelectionFunc :: TreeSelectionFunc -> TreeSelectionFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeSelectionFunc :: MonadIO m => TreeSelectionFunc -> m (GClosure C_TreeSelectionFunc)

-- | Wrap a <a>TreeSelectionFunc</a> into a <a>C_TreeSelectionFunc</a>.
wrap_TreeSelectionFunc :: Maybe (Ptr (FunPtr C_TreeSelectionFunc)) -> TreeSelectionFunc_WithClosures -> C_TreeSelectionFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeSelectionForeachFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeSelectionForeachFunc -> a -> TreePath -> TreeIter -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeSelectionForeachFunc</a></tt>.
noTreeSelectionForeachFunc :: Maybe TreeSelectionForeachFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeSelectionForeachFunc_WithClosures</a></tt>.
noTreeSelectionForeachFunc_WithClosures :: Maybe TreeSelectionForeachFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeSelectionForeachFunc :: TreeSelectionForeachFunc -> TreeSelectionForeachFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeSelectionForeachFunc :: MonadIO m => TreeSelectionForeachFunc -> m (GClosure C_TreeSelectionForeachFunc)

-- | Wrap a <a>TreeSelectionForeachFunc</a> into a
--   <a>C_TreeSelectionForeachFunc</a>.
wrap_TreeSelectionForeachFunc :: Maybe (Ptr (FunPtr C_TreeSelectionForeachFunc)) -> TreeSelectionForeachFunc_WithClosures -> C_TreeSelectionForeachFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeModelForeachFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeModelForeachFunc -> a -> TreePath -> TreeIter -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeModelForeachFunc</a></tt>.
noTreeModelForeachFunc :: Maybe TreeModelForeachFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeModelForeachFunc_WithClosures</a></tt>.
noTreeModelForeachFunc_WithClosures :: Maybe TreeModelForeachFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeModelForeachFunc :: TreeModelForeachFunc -> TreeModelForeachFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeModelForeachFunc :: MonadIO m => TreeModelForeachFunc -> m (GClosure C_TreeModelForeachFunc)

-- | Wrap a <a>TreeModelForeachFunc</a> into a
--   <a>C_TreeModelForeachFunc</a>.
wrap_TreeModelForeachFunc :: Maybe (Ptr (FunPtr C_TreeModelForeachFunc)) -> TreeModelForeachFunc_WithClosures -> C_TreeModelForeachFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeModelFilterVisibleFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeModelFilterVisibleFunc -> a -> TreeIter -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeModelFilterVisibleFunc</a></tt>.
noTreeModelFilterVisibleFunc :: Maybe TreeModelFilterVisibleFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeModelFilterVisibleFunc_WithClosures</a></tt>.
noTreeModelFilterVisibleFunc_WithClosures :: Maybe TreeModelFilterVisibleFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeModelFilterVisibleFunc :: TreeModelFilterVisibleFunc -> TreeModelFilterVisibleFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeModelFilterVisibleFunc :: MonadIO m => TreeModelFilterVisibleFunc -> m (GClosure C_TreeModelFilterVisibleFunc)

-- | Wrap a <a>TreeModelFilterVisibleFunc</a> into a
--   <a>C_TreeModelFilterVisibleFunc</a>.
wrap_TreeModelFilterVisibleFunc :: Maybe (Ptr (FunPtr C_TreeModelFilterVisibleFunc)) -> TreeModelFilterVisibleFunc_WithClosures -> C_TreeModelFilterVisibleFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeModelFilterModifyFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeModelFilterModifyFunc -> a -> TreeIter -> Int32 -> Ptr () -> m GValue

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeModelFilterModifyFunc</a></tt>.
noTreeModelFilterModifyFunc :: Maybe TreeModelFilterModifyFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeModelFilterModifyFunc_WithClosures</a></tt>.
noTreeModelFilterModifyFunc_WithClosures :: Maybe TreeModelFilterModifyFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeModelFilterModifyFunc :: TreeModelFilterModifyFunc -> TreeModelFilterModifyFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeModelFilterModifyFunc :: MonadIO m => TreeModelFilterModifyFunc -> m (GClosure C_TreeModelFilterModifyFunc)

-- | Wrap a <a>TreeModelFilterModifyFunc</a> into a
--   <a>C_TreeModelFilterModifyFunc</a>.
wrap_TreeModelFilterModifyFunc :: Maybe (Ptr (FunPtr C_TreeModelFilterModifyFunc)) -> TreeModelFilterModifyFunc_WithClosures -> C_TreeModelFilterModifyFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeIterCompareFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeIterCompareFunc -> a -> TreeIter -> TreeIter -> Ptr () -> m Int32

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeIterCompareFunc</a></tt>.
noTreeIterCompareFunc :: Maybe TreeIterCompareFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeIterCompareFunc_WithClosures</a></tt>.
noTreeIterCompareFunc_WithClosures :: Maybe TreeIterCompareFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeIterCompareFunc :: TreeIterCompareFunc -> TreeIterCompareFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeIterCompareFunc :: MonadIO m => TreeIterCompareFunc -> m (GClosure C_TreeIterCompareFunc)

-- | Wrap a <a>TreeIterCompareFunc</a> into a <a>C_TreeIterCompareFunc</a>.
wrap_TreeIterCompareFunc :: Maybe (Ptr (FunPtr C_TreeIterCompareFunc)) -> TreeIterCompareFunc_WithClosures -> C_TreeIterCompareFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeDestroyCountFunc :: (HasCallStack, MonadIO m, IsTreeView a) => FunPtr C_TreeDestroyCountFunc -> a -> TreePath -> Int32 -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeDestroyCountFunc</a></tt>.
noTreeDestroyCountFunc :: Maybe TreeDestroyCountFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeDestroyCountFunc_WithClosures</a></tt>.
noTreeDestroyCountFunc_WithClosures :: Maybe TreeDestroyCountFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeDestroyCountFunc :: TreeDestroyCountFunc -> TreeDestroyCountFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeDestroyCountFunc :: MonadIO m => TreeDestroyCountFunc -> m (GClosure C_TreeDestroyCountFunc)

-- | Wrap a <a>TreeDestroyCountFunc</a> into a
--   <a>C_TreeDestroyCountFunc</a>.
wrap_TreeDestroyCountFunc :: Maybe (Ptr (FunPtr C_TreeDestroyCountFunc)) -> TreeDestroyCountFunc_WithClosures -> C_TreeDestroyCountFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeCellDataFunc :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b, IsTreeModel c) => FunPtr C_TreeCellDataFunc -> a -> b -> c -> TreeIter -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeCellDataFunc</a></tt>.
noTreeCellDataFunc :: Maybe TreeCellDataFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeCellDataFunc_WithClosures</a></tt>.
noTreeCellDataFunc_WithClosures :: Maybe TreeCellDataFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeCellDataFunc :: TreeCellDataFunc -> TreeCellDataFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeCellDataFunc :: MonadIO m => TreeCellDataFunc -> m (GClosure C_TreeCellDataFunc)

-- | Wrap a <a>TreeCellDataFunc</a> into a <a>C_TreeCellDataFunc</a>.
wrap_TreeCellDataFunc :: Maybe (Ptr (FunPtr C_TreeCellDataFunc)) -> TreeCellDataFunc_WithClosures -> C_TreeCellDataFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TickCallback :: (HasCallStack, MonadIO m, IsWidget a, IsFrameClock b) => FunPtr C_TickCallback -> a -> b -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TickCallback</a></tt>.
noTickCallback :: Maybe TickCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TickCallback_WithClosures</a></tt>.
noTickCallback_WithClosures :: Maybe TickCallback_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TickCallback :: TickCallback -> TickCallback_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TickCallback :: MonadIO m => TickCallback -> m (GClosure C_TickCallback)

-- | Wrap a <a>TickCallback</a> into a <a>C_TickCallback</a>.
wrap_TickCallback :: Maybe (Ptr (FunPtr C_TickCallback)) -> TickCallback_WithClosures -> C_TickCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TextTagTableForeach :: (HasCallStack, MonadIO m, IsTextTag a) => FunPtr C_TextTagTableForeach -> a -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TextTagTableForeach</a></tt>.
noTextTagTableForeach :: Maybe TextTagTableForeach

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TextTagTableForeach_WithClosures</a></tt>.
noTextTagTableForeach_WithClosures :: Maybe TextTagTableForeach_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TextTagTableForeach :: TextTagTableForeach -> TextTagTableForeach_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TextTagTableForeach :: MonadIO m => TextTagTableForeach -> m (GClosure C_TextTagTableForeach)

-- | Wrap a <a>TextTagTableForeach</a> into a <a>C_TextTagTableForeach</a>.
wrap_TextTagTableForeach :: Maybe (Ptr (FunPtr C_TextTagTableForeach)) -> TextTagTableForeach_WithClosures -> C_TextTagTableForeach

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TextCharPredicate :: (HasCallStack, MonadIO m) => FunPtr C_TextCharPredicate -> Char -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TextCharPredicate</a></tt>.
noTextCharPredicate :: Maybe TextCharPredicate

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TextCharPredicate_WithClosures</a></tt>.
noTextCharPredicate_WithClosures :: Maybe TextCharPredicate_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TextCharPredicate :: TextCharPredicate -> TextCharPredicate_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TextCharPredicate :: MonadIO m => TextCharPredicate -> m (GClosure C_TextCharPredicate)

-- | Wrap a <a>TextCharPredicate</a> into a <a>C_TextCharPredicate</a>.
wrap_TextCharPredicate :: Maybe (Ptr (FunPtr C_TextCharPredicate)) -> TextCharPredicate_WithClosures -> C_TextCharPredicate

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TextBufferSerializeFunc :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextBuffer b) => FunPtr C_TextBufferSerializeFunc -> a -> b -> TextIter -> TextIter -> Ptr () -> m (Maybe ByteString)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TextBufferSerializeFunc</a></tt>.
noTextBufferSerializeFunc :: Maybe TextBufferSerializeFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TextBufferSerializeFunc_WithClosures</a></tt>.
noTextBufferSerializeFunc_WithClosures :: Maybe TextBufferSerializeFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TextBufferSerializeFunc :: TextBufferSerializeFunc -> TextBufferSerializeFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TextBufferSerializeFunc :: MonadIO m => TextBufferSerializeFunc -> m (GClosure C_TextBufferSerializeFunc)

-- | Wrap a <a>TextBufferSerializeFunc</a> into a
--   <a>C_TextBufferSerializeFunc</a>.
wrap_TextBufferSerializeFunc :: Maybe (Ptr (FunPtr C_TextBufferSerializeFunc)) -> TextBufferSerializeFunc_WithClosures -> C_TextBufferSerializeFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TextBufferDeserializeFunc :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextBuffer b) => FunPtr C_TextBufferDeserializeFunc -> a -> b -> TextIter -> ByteString -> Bool -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TextBufferDeserializeFunc</a></tt>.
noTextBufferDeserializeFunc :: Maybe TextBufferDeserializeFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TextBufferDeserializeFunc_WithClosures</a></tt>.
noTextBufferDeserializeFunc_WithClosures :: Maybe TextBufferDeserializeFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TextBufferDeserializeFunc :: TextBufferDeserializeFunc -> TextBufferDeserializeFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_StylePropertyParser :: (HasCallStack, MonadIO m) => FunPtr C_StylePropertyParser -> Text -> GValue -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>StylePropertyParser</a></tt>.
noStylePropertyParser :: Maybe StylePropertyParser

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_RecentSortFunc :: (HasCallStack, MonadIO m) => FunPtr C_RecentSortFunc -> RecentInfo -> RecentInfo -> Ptr () -> m Int32

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RecentSortFunc</a></tt>.
noRecentSortFunc :: Maybe RecentSortFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RecentSortFunc_WithClosures</a></tt>.
noRecentSortFunc_WithClosures :: Maybe RecentSortFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RecentSortFunc :: RecentSortFunc -> RecentSortFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_RecentSortFunc :: MonadIO m => RecentSortFunc -> m (GClosure C_RecentSortFunc)

-- | Wrap a <a>RecentSortFunc</a> into a <a>C_RecentSortFunc</a>.
wrap_RecentSortFunc :: Maybe (Ptr (FunPtr C_RecentSortFunc)) -> RecentSortFunc_WithClosures -> C_RecentSortFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_RecentFilterFunc :: (HasCallStack, MonadIO m) => FunPtr C_RecentFilterFunc -> RecentFilterInfo -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RecentFilterFunc</a></tt>.
noRecentFilterFunc :: Maybe RecentFilterFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RecentFilterFunc_WithClosures</a></tt>.
noRecentFilterFunc_WithClosures :: Maybe RecentFilterFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RecentFilterFunc :: RecentFilterFunc -> RecentFilterFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_RecentFilterFunc :: MonadIO m => RecentFilterFunc -> m (GClosure C_RecentFilterFunc)

-- | Wrap a <a>RecentFilterFunc</a> into a <a>C_RecentFilterFunc</a>.
wrap_RecentFilterFunc :: Maybe (Ptr (FunPtr C_RecentFilterFunc)) -> RecentFilterFunc_WithClosures -> C_RecentFilterFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_RcPropertyParser :: (HasCallStack, MonadIO m) => FunPtr C_RcPropertyParser -> GParamSpec -> String -> GValue -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RcPropertyParser</a></tt>.
noRcPropertyParser :: Maybe RcPropertyParser

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_RcPropertyParser :: MonadIO m => RcPropertyParser -> m (GClosure C_RcPropertyParser)

-- | Wrap a <a>RcPropertyParser</a> into a <a>C_RcPropertyParser</a>.
wrap_RcPropertyParser :: Maybe (Ptr (FunPtr C_RcPropertyParser)) -> RcPropertyParser -> C_RcPropertyParser

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_PrintSettingsFunc :: (HasCallStack, MonadIO m) => FunPtr C_PrintSettingsFunc -> Text -> Text -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>PrintSettingsFunc</a></tt>.
noPrintSettingsFunc :: Maybe PrintSettingsFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>PrintSettingsFunc_WithClosures</a></tt>.
noPrintSettingsFunc_WithClosures :: Maybe PrintSettingsFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_PrintSettingsFunc :: PrintSettingsFunc -> PrintSettingsFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_PrintSettingsFunc :: MonadIO m => PrintSettingsFunc -> m (GClosure C_PrintSettingsFunc)

-- | Wrap a <a>PrintSettingsFunc</a> into a <a>C_PrintSettingsFunc</a>.
wrap_PrintSettingsFunc :: Maybe (Ptr (FunPtr C_PrintSettingsFunc)) -> PrintSettingsFunc_WithClosures -> C_PrintSettingsFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_PageSetupDoneFunc :: (HasCallStack, MonadIO m, IsPageSetup a) => FunPtr C_PageSetupDoneFunc -> a -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>PageSetupDoneFunc</a></tt>.
noPageSetupDoneFunc :: Maybe PageSetupDoneFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>PageSetupDoneFunc_WithClosures</a></tt>.
noPageSetupDoneFunc_WithClosures :: Maybe PageSetupDoneFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_PageSetupDoneFunc :: PageSetupDoneFunc -> PageSetupDoneFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_PageSetupDoneFunc :: MonadIO m => PageSetupDoneFunc -> m (GClosure C_PageSetupDoneFunc)

-- | Wrap a <a>PageSetupDoneFunc</a> into a <a>C_PageSetupDoneFunc</a>.
wrap_PageSetupDoneFunc :: Maybe (Ptr (FunPtr C_PageSetupDoneFunc)) -> PageSetupDoneFunc_WithClosures -> C_PageSetupDoneFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ModuleInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_ModuleInitFunc -> Maybe [Text] -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ModuleInitFunc</a></tt>.
noModuleInitFunc :: Maybe ModuleInitFunc

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ModuleInitFunc :: MonadIO m => ModuleInitFunc -> m (GClosure C_ModuleInitFunc)

-- | Wrap a <a>ModuleInitFunc</a> into a <a>C_ModuleInitFunc</a>.
wrap_ModuleInitFunc :: Maybe (Ptr (FunPtr C_ModuleInitFunc)) -> ModuleInitFunc -> C_ModuleInitFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ModuleDisplayInitFunc :: (HasCallStack, MonadIO m, IsDisplay a) => FunPtr C_ModuleDisplayInitFunc -> a -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ModuleDisplayInitFunc</a></tt>.
noModuleDisplayInitFunc :: Maybe ModuleDisplayInitFunc

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ModuleDisplayInitFunc :: MonadIO m => ModuleDisplayInitFunc -> m (GClosure C_ModuleDisplayInitFunc)

-- | Wrap a <a>ModuleDisplayInitFunc</a> into a
--   <a>C_ModuleDisplayInitFunc</a>.
wrap_ModuleDisplayInitFunc :: Maybe (Ptr (FunPtr C_ModuleDisplayInitFunc)) -> ModuleDisplayInitFunc -> C_ModuleDisplayInitFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_MenuPositionFunc :: (HasCallStack, MonadIO m, IsMenu a) => FunPtr C_MenuPositionFunc -> a -> Int32 -> Int32 -> Ptr () -> m (Int32, Int32, Bool)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>MenuPositionFunc</a></tt>.
noMenuPositionFunc :: Maybe MenuPositionFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>MenuPositionFunc_WithClosures</a></tt>.
noMenuPositionFunc_WithClosures :: Maybe MenuPositionFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_MenuPositionFunc :: MenuPositionFunc -> MenuPositionFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_MenuPositionFunc :: MonadIO m => MenuPositionFunc -> m (GClosure C_MenuPositionFunc)

-- | Wrap a <a>MenuPositionFunc</a> into a <a>C_MenuPositionFunc</a>.
wrap_MenuPositionFunc :: Maybe (Ptr (FunPtr C_MenuPositionFunc)) -> MenuPositionFunc_WithClosures -> C_MenuPositionFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_MenuDetachFunc :: (HasCallStack, MonadIO m, IsWidget a, IsMenu b) => FunPtr C_MenuDetachFunc -> a -> b -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>MenuDetachFunc</a></tt>.
noMenuDetachFunc :: Maybe MenuDetachFunc

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_MenuDetachFunc :: MonadIO m => MenuDetachFunc -> m (GClosure C_MenuDetachFunc)

-- | Wrap a <a>MenuDetachFunc</a> into a <a>C_MenuDetachFunc</a>.
wrap_MenuDetachFunc :: Maybe (Ptr (FunPtr C_MenuDetachFunc)) -> MenuDetachFunc -> C_MenuDetachFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ListBoxUpdateHeaderFunc :: (HasCallStack, MonadIO m, IsListBoxRow a, IsListBoxRow b) => FunPtr C_ListBoxUpdateHeaderFunc -> a -> Maybe b -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxUpdateHeaderFunc</a></tt>.
noListBoxUpdateHeaderFunc :: Maybe ListBoxUpdateHeaderFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxUpdateHeaderFunc_WithClosures</a></tt>.
noListBoxUpdateHeaderFunc_WithClosures :: Maybe ListBoxUpdateHeaderFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ListBoxUpdateHeaderFunc :: ListBoxUpdateHeaderFunc -> ListBoxUpdateHeaderFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ListBoxUpdateHeaderFunc :: MonadIO m => ListBoxUpdateHeaderFunc -> m (GClosure C_ListBoxUpdateHeaderFunc)

-- | Wrap a <a>ListBoxUpdateHeaderFunc</a> into a
--   <a>C_ListBoxUpdateHeaderFunc</a>.
wrap_ListBoxUpdateHeaderFunc :: Maybe (Ptr (FunPtr C_ListBoxUpdateHeaderFunc)) -> ListBoxUpdateHeaderFunc_WithClosures -> C_ListBoxUpdateHeaderFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ListBoxSortFunc :: (HasCallStack, MonadIO m, IsListBoxRow a, IsListBoxRow b) => FunPtr C_ListBoxSortFunc -> a -> b -> Ptr () -> m Int32

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxSortFunc</a></tt>.
noListBoxSortFunc :: Maybe ListBoxSortFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxSortFunc_WithClosures</a></tt>.
noListBoxSortFunc_WithClosures :: Maybe ListBoxSortFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ListBoxSortFunc :: ListBoxSortFunc -> ListBoxSortFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ListBoxSortFunc :: MonadIO m => ListBoxSortFunc -> m (GClosure C_ListBoxSortFunc)

-- | Wrap a <a>ListBoxSortFunc</a> into a <a>C_ListBoxSortFunc</a>.
wrap_ListBoxSortFunc :: Maybe (Ptr (FunPtr C_ListBoxSortFunc)) -> ListBoxSortFunc_WithClosures -> C_ListBoxSortFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ListBoxForeachFunc :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => FunPtr C_ListBoxForeachFunc -> a -> b -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxForeachFunc</a></tt>.
noListBoxForeachFunc :: Maybe ListBoxForeachFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxForeachFunc_WithClosures</a></tt>.
noListBoxForeachFunc_WithClosures :: Maybe ListBoxForeachFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ListBoxForeachFunc :: ListBoxForeachFunc -> ListBoxForeachFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ListBoxForeachFunc :: MonadIO m => ListBoxForeachFunc -> m (GClosure C_ListBoxForeachFunc)

-- | Wrap a <a>ListBoxForeachFunc</a> into a <a>C_ListBoxForeachFunc</a>.
wrap_ListBoxForeachFunc :: Maybe (Ptr (FunPtr C_ListBoxForeachFunc)) -> ListBoxForeachFunc_WithClosures -> C_ListBoxForeachFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ListBoxFilterFunc :: (HasCallStack, MonadIO m, IsListBoxRow a) => FunPtr C_ListBoxFilterFunc -> a -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxFilterFunc</a></tt>.
noListBoxFilterFunc :: Maybe ListBoxFilterFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxFilterFunc_WithClosures</a></tt>.
noListBoxFilterFunc_WithClosures :: Maybe ListBoxFilterFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ListBoxFilterFunc :: ListBoxFilterFunc -> ListBoxFilterFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ListBoxFilterFunc :: MonadIO m => ListBoxFilterFunc -> m (GClosure C_ListBoxFilterFunc)

-- | Wrap a <a>ListBoxFilterFunc</a> into a <a>C_ListBoxFilterFunc</a>.
wrap_ListBoxFilterFunc :: Maybe (Ptr (FunPtr C_ListBoxFilterFunc)) -> ListBoxFilterFunc_WithClosures -> C_ListBoxFilterFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ListBoxCreateWidgetFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ListBoxCreateWidgetFunc -> a -> Ptr () -> m Widget

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxCreateWidgetFunc</a></tt>.
noListBoxCreateWidgetFunc :: Maybe ListBoxCreateWidgetFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxCreateWidgetFunc_WithClosures</a></tt>.
noListBoxCreateWidgetFunc_WithClosures :: Maybe ListBoxCreateWidgetFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ListBoxCreateWidgetFunc :: ListBoxCreateWidgetFunc -> ListBoxCreateWidgetFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ListBoxCreateWidgetFunc :: MonadIO m => ListBoxCreateWidgetFunc -> m (GClosure C_ListBoxCreateWidgetFunc)

-- | Wrap a <a>ListBoxCreateWidgetFunc</a> into a
--   <a>C_ListBoxCreateWidgetFunc</a>.
wrap_ListBoxCreateWidgetFunc :: Maybe (Ptr (FunPtr C_ListBoxCreateWidgetFunc)) -> ListBoxCreateWidgetFunc_WithClosures -> C_ListBoxCreateWidgetFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_KeySnoopFunc :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_KeySnoopFunc -> a -> EventKey -> Ptr () -> m Int32

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>KeySnoopFunc</a></tt>.
noKeySnoopFunc :: Maybe KeySnoopFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>KeySnoopFunc_WithClosures</a></tt>.
noKeySnoopFunc_WithClosures :: Maybe KeySnoopFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_KeySnoopFunc :: KeySnoopFunc -> KeySnoopFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_KeySnoopFunc :: MonadIO m => KeySnoopFunc -> m (GClosure C_KeySnoopFunc)

-- | Wrap a <a>KeySnoopFunc</a> into a <a>C_KeySnoopFunc</a>.
wrap_KeySnoopFunc :: Maybe (Ptr (FunPtr C_KeySnoopFunc)) -> KeySnoopFunc_WithClosures -> C_KeySnoopFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_IconViewForeachFunc :: (HasCallStack, MonadIO m, IsIconView a) => FunPtr C_IconViewForeachFunc -> a -> TreePath -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>IconViewForeachFunc</a></tt>.
noIconViewForeachFunc :: Maybe IconViewForeachFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>IconViewForeachFunc_WithClosures</a></tt>.
noIconViewForeachFunc_WithClosures :: Maybe IconViewForeachFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_IconViewForeachFunc :: IconViewForeachFunc -> IconViewForeachFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_IconViewForeachFunc :: MonadIO m => IconViewForeachFunc -> m (GClosure C_IconViewForeachFunc)

-- | Wrap a <a>IconViewForeachFunc</a> into a <a>C_IconViewForeachFunc</a>.
wrap_IconViewForeachFunc :: Maybe (Ptr (FunPtr C_IconViewForeachFunc)) -> IconViewForeachFunc_WithClosures -> C_IconViewForeachFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_FontFilterFunc :: (HasCallStack, MonadIO m, IsFontFamily a, IsFontFace b) => FunPtr C_FontFilterFunc -> a -> b -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FontFilterFunc</a></tt>.
noFontFilterFunc :: Maybe FontFilterFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FontFilterFunc_WithClosures</a></tt>.
noFontFilterFunc_WithClosures :: Maybe FontFilterFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FontFilterFunc :: FontFilterFunc -> FontFilterFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_FontFilterFunc :: MonadIO m => FontFilterFunc -> m (GClosure C_FontFilterFunc)

-- | Wrap a <a>FontFilterFunc</a> into a <a>C_FontFilterFunc</a>.
wrap_FontFilterFunc :: Maybe (Ptr (FunPtr C_FontFilterFunc)) -> FontFilterFunc_WithClosures -> C_FontFilterFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_FlowBoxSortFunc :: (HasCallStack, MonadIO m, IsFlowBoxChild a, IsFlowBoxChild b) => FunPtr C_FlowBoxSortFunc -> a -> b -> Ptr () -> m Int32

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FlowBoxSortFunc</a></tt>.
noFlowBoxSortFunc :: Maybe FlowBoxSortFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FlowBoxSortFunc_WithClosures</a></tt>.
noFlowBoxSortFunc_WithClosures :: Maybe FlowBoxSortFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FlowBoxSortFunc :: FlowBoxSortFunc -> FlowBoxSortFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_FlowBoxSortFunc :: MonadIO m => FlowBoxSortFunc -> m (GClosure C_FlowBoxSortFunc)

-- | Wrap a <a>FlowBoxSortFunc</a> into a <a>C_FlowBoxSortFunc</a>.
wrap_FlowBoxSortFunc :: Maybe (Ptr (FunPtr C_FlowBoxSortFunc)) -> FlowBoxSortFunc_WithClosures -> C_FlowBoxSortFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_FlowBoxForeachFunc :: (HasCallStack, MonadIO m, IsFlowBox a, IsFlowBoxChild b) => FunPtr C_FlowBoxForeachFunc -> a -> b -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FlowBoxForeachFunc</a></tt>.
noFlowBoxForeachFunc :: Maybe FlowBoxForeachFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FlowBoxForeachFunc_WithClosures</a></tt>.
noFlowBoxForeachFunc_WithClosures :: Maybe FlowBoxForeachFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FlowBoxForeachFunc :: FlowBoxForeachFunc -> FlowBoxForeachFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_FlowBoxForeachFunc :: MonadIO m => FlowBoxForeachFunc -> m (GClosure C_FlowBoxForeachFunc)

-- | Wrap a <a>FlowBoxForeachFunc</a> into a <a>C_FlowBoxForeachFunc</a>.
wrap_FlowBoxForeachFunc :: Maybe (Ptr (FunPtr C_FlowBoxForeachFunc)) -> FlowBoxForeachFunc_WithClosures -> C_FlowBoxForeachFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_FlowBoxFilterFunc :: (HasCallStack, MonadIO m, IsFlowBoxChild a) => FunPtr C_FlowBoxFilterFunc -> a -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FlowBoxFilterFunc</a></tt>.
noFlowBoxFilterFunc :: Maybe FlowBoxFilterFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FlowBoxFilterFunc_WithClosures</a></tt>.
noFlowBoxFilterFunc_WithClosures :: Maybe FlowBoxFilterFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FlowBoxFilterFunc :: FlowBoxFilterFunc -> FlowBoxFilterFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_FlowBoxFilterFunc :: MonadIO m => FlowBoxFilterFunc -> m (GClosure C_FlowBoxFilterFunc)

-- | Wrap a <a>FlowBoxFilterFunc</a> into a <a>C_FlowBoxFilterFunc</a>.
wrap_FlowBoxFilterFunc :: Maybe (Ptr (FunPtr C_FlowBoxFilterFunc)) -> FlowBoxFilterFunc_WithClosures -> C_FlowBoxFilterFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_FlowBoxCreateWidgetFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_FlowBoxCreateWidgetFunc -> Maybe a -> Ptr () -> m Widget

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FlowBoxCreateWidgetFunc</a></tt>.
noFlowBoxCreateWidgetFunc :: Maybe FlowBoxCreateWidgetFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FlowBoxCreateWidgetFunc_WithClosures</a></tt>.
noFlowBoxCreateWidgetFunc_WithClosures :: Maybe FlowBoxCreateWidgetFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FlowBoxCreateWidgetFunc :: FlowBoxCreateWidgetFunc -> FlowBoxCreateWidgetFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_FlowBoxCreateWidgetFunc :: MonadIO m => FlowBoxCreateWidgetFunc -> m (GClosure C_FlowBoxCreateWidgetFunc)

-- | Wrap a <a>FlowBoxCreateWidgetFunc</a> into a
--   <a>C_FlowBoxCreateWidgetFunc</a>.
wrap_FlowBoxCreateWidgetFunc :: Maybe (Ptr (FunPtr C_FlowBoxCreateWidgetFunc)) -> FlowBoxCreateWidgetFunc_WithClosures -> C_FlowBoxCreateWidgetFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_FileFilterFunc :: (HasCallStack, MonadIO m) => FunPtr C_FileFilterFunc -> FileFilterInfo -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FileFilterFunc</a></tt>.
noFileFilterFunc :: Maybe FileFilterFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FileFilterFunc_WithClosures</a></tt>.
noFileFilterFunc_WithClosures :: Maybe FileFilterFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FileFilterFunc :: FileFilterFunc -> FileFilterFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_FileFilterFunc :: MonadIO m => FileFilterFunc -> m (GClosure C_FileFilterFunc)

-- | Wrap a <a>FileFilterFunc</a> into a <a>C_FileFilterFunc</a>.
wrap_FileFilterFunc :: Maybe (Ptr (FunPtr C_FileFilterFunc)) -> FileFilterFunc_WithClosures -> C_FileFilterFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_EntryCompletionMatchFunc :: (HasCallStack, MonadIO m, IsEntryCompletion a) => FunPtr C_EntryCompletionMatchFunc -> a -> Text -> TreeIter -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>EntryCompletionMatchFunc</a></tt>.
noEntryCompletionMatchFunc :: Maybe EntryCompletionMatchFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>EntryCompletionMatchFunc_WithClosures</a></tt>.
noEntryCompletionMatchFunc_WithClosures :: Maybe EntryCompletionMatchFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_EntryCompletionMatchFunc :: EntryCompletionMatchFunc -> EntryCompletionMatchFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_EntryCompletionMatchFunc :: MonadIO m => EntryCompletionMatchFunc -> m (GClosure C_EntryCompletionMatchFunc)

-- | Wrap a <a>EntryCompletionMatchFunc</a> into a
--   <a>C_EntryCompletionMatchFunc</a>.
wrap_EntryCompletionMatchFunc :: Maybe (Ptr (FunPtr C_EntryCompletionMatchFunc)) -> EntryCompletionMatchFunc_WithClosures -> C_EntryCompletionMatchFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ContainerClassSetFocusChildFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassSetFocusChildFieldCallback -> a -> Maybe b -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ContainerClassSetFocusChildFieldCallback</a></tt>.
noContainerClassSetFocusChildFieldCallback :: Maybe ContainerClassSetFocusChildFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ContainerClassSetFocusChildFieldCallback :: MonadIO m => ContainerClassSetFocusChildFieldCallback -> m (GClosure C_ContainerClassSetFocusChildFieldCallback)

-- | Wrap a <a>ContainerClassSetFocusChildFieldCallback</a> into a
--   <a>C_ContainerClassSetFocusChildFieldCallback</a>.
wrap_ContainerClassSetFocusChildFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassSetFocusChildFieldCallback)) -> ContainerClassSetFocusChildFieldCallback -> C_ContainerClassSetFocusChildFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ContainerClassSetChildPropertyFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassSetChildPropertyFieldCallback -> a -> b -> Word32 -> GValue -> GParamSpec -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ContainerClassSetChildPropertyFieldCallback</a></tt>.
noContainerClassSetChildPropertyFieldCallback :: Maybe ContainerClassSetChildPropertyFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ContainerClassSetChildPropertyFieldCallback :: MonadIO m => ContainerClassSetChildPropertyFieldCallback -> m (GClosure C_ContainerClassSetChildPropertyFieldCallback)

-- | Wrap a <a>ContainerClassSetChildPropertyFieldCallback</a> into a
--   <a>C_ContainerClassSetChildPropertyFieldCallback</a>.
wrap_ContainerClassSetChildPropertyFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassSetChildPropertyFieldCallback)) -> ContainerClassSetChildPropertyFieldCallback -> C_ContainerClassSetChildPropertyFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ContainerClassRemoveFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassRemoveFieldCallback -> a -> b -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ContainerClassRemoveFieldCallback</a></tt>.
noContainerClassRemoveFieldCallback :: Maybe ContainerClassRemoveFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ContainerClassRemoveFieldCallback :: MonadIO m => ContainerClassRemoveFieldCallback -> m (GClosure C_ContainerClassRemoveFieldCallback)

-- | Wrap a <a>ContainerClassRemoveFieldCallback</a> into a
--   <a>C_ContainerClassRemoveFieldCallback</a>.
wrap_ContainerClassRemoveFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassRemoveFieldCallback)) -> ContainerClassRemoveFieldCallback -> C_ContainerClassRemoveFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ContainerClassGetPathForChildFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassGetPathForChildFieldCallback -> a -> b -> m WidgetPath

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ContainerClassGetPathForChildFieldCallback</a></tt>.
noContainerClassGetPathForChildFieldCallback :: Maybe ContainerClassGetPathForChildFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ContainerClassGetPathForChildFieldCallback :: MonadIO m => ContainerClassGetPathForChildFieldCallback -> m (GClosure C_ContainerClassGetPathForChildFieldCallback)

-- | Wrap a <a>ContainerClassGetPathForChildFieldCallback</a> into a
--   <a>C_ContainerClassGetPathForChildFieldCallback</a>.
wrap_ContainerClassGetPathForChildFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassGetPathForChildFieldCallback)) -> ContainerClassGetPathForChildFieldCallback -> C_ContainerClassGetPathForChildFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ContainerClassGetChildPropertyFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassGetChildPropertyFieldCallback -> a -> b -> Word32 -> GValue -> GParamSpec -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ContainerClassGetChildPropertyFieldCallback</a></tt>.
noContainerClassGetChildPropertyFieldCallback :: Maybe ContainerClassGetChildPropertyFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ContainerClassGetChildPropertyFieldCallback :: MonadIO m => ContainerClassGetChildPropertyFieldCallback -> m (GClosure C_ContainerClassGetChildPropertyFieldCallback)

-- | Wrap a <a>ContainerClassGetChildPropertyFieldCallback</a> into a
--   <a>C_ContainerClassGetChildPropertyFieldCallback</a>.
wrap_ContainerClassGetChildPropertyFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassGetChildPropertyFieldCallback)) -> ContainerClassGetChildPropertyFieldCallback -> C_ContainerClassGetChildPropertyFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ContainerClassForallFieldCallback :: (HasCallStack, MonadIO m, IsContainer a) => FunPtr C_ContainerClassForallFieldCallback -> a -> Bool -> Callback_WithClosures -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ContainerClassForallFieldCallback</a></tt>.
noContainerClassForallFieldCallback :: Maybe ContainerClassForallFieldCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ContainerClassForallFieldCallback_WithClosures</a></tt>.
noContainerClassForallFieldCallback_WithClosures :: Maybe ContainerClassForallFieldCallback_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ContainerClassForallFieldCallback :: ContainerClassForallFieldCallback -> ContainerClassForallFieldCallback_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ContainerClassForallFieldCallback :: MonadIO m => ContainerClassForallFieldCallback -> m (GClosure C_ContainerClassForallFieldCallback)

-- | Wrap a <a>ContainerClassForallFieldCallback</a> into a
--   <a>C_ContainerClassForallFieldCallback</a>.
wrap_ContainerClassForallFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassForallFieldCallback)) -> ContainerClassForallFieldCallback_WithClosures -> C_ContainerClassForallFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ContainerClassCompositeNameFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassCompositeNameFieldCallback -> a -> b -> m Text

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ContainerClassCompositeNameFieldCallback</a></tt>.
noContainerClassCompositeNameFieldCallback :: Maybe ContainerClassCompositeNameFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ContainerClassCompositeNameFieldCallback :: MonadIO m => ContainerClassCompositeNameFieldCallback -> m (GClosure C_ContainerClassCompositeNameFieldCallback)

-- | Wrap a <a>ContainerClassCompositeNameFieldCallback</a> into a
--   <a>C_ContainerClassCompositeNameFieldCallback</a>.
wrap_ContainerClassCompositeNameFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassCompositeNameFieldCallback)) -> ContainerClassCompositeNameFieldCallback -> C_ContainerClassCompositeNameFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ContainerClassChildTypeFieldCallback :: (HasCallStack, MonadIO m, IsContainer a) => FunPtr C_ContainerClassChildTypeFieldCallback -> a -> m GType

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ContainerClassChildTypeFieldCallback</a></tt>.
noContainerClassChildTypeFieldCallback :: Maybe ContainerClassChildTypeFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ContainerClassChildTypeFieldCallback :: MonadIO m => ContainerClassChildTypeFieldCallback -> m (GClosure C_ContainerClassChildTypeFieldCallback)

-- | Wrap a <a>ContainerClassChildTypeFieldCallback</a> into a
--   <a>C_ContainerClassChildTypeFieldCallback</a>.
wrap_ContainerClassChildTypeFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassChildTypeFieldCallback)) -> ContainerClassChildTypeFieldCallback -> C_ContainerClassChildTypeFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ContainerClassCheckResizeFieldCallback :: (HasCallStack, MonadIO m, IsContainer a) => FunPtr C_ContainerClassCheckResizeFieldCallback -> a -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ContainerClassCheckResizeFieldCallback</a></tt>.
noContainerClassCheckResizeFieldCallback :: Maybe ContainerClassCheckResizeFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ContainerClassCheckResizeFieldCallback :: MonadIO m => ContainerClassCheckResizeFieldCallback -> m (GClosure C_ContainerClassCheckResizeFieldCallback)

-- | Wrap a <a>ContainerClassCheckResizeFieldCallback</a> into a
--   <a>C_ContainerClassCheckResizeFieldCallback</a>.
wrap_ContainerClassCheckResizeFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassCheckResizeFieldCallback)) -> ContainerClassCheckResizeFieldCallback -> C_ContainerClassCheckResizeFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ContainerClassAddFieldCallback :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => FunPtr C_ContainerClassAddFieldCallback -> a -> b -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ContainerClassAddFieldCallback</a></tt>.
noContainerClassAddFieldCallback :: Maybe ContainerClassAddFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ContainerClassAddFieldCallback :: MonadIO m => ContainerClassAddFieldCallback -> m (GClosure C_ContainerClassAddFieldCallback)

-- | Wrap a <a>ContainerClassAddFieldCallback</a> into a
--   <a>C_ContainerClassAddFieldCallback</a>.
wrap_ContainerClassAddFieldCallback :: Maybe (Ptr (FunPtr C_ContainerClassAddFieldCallback)) -> ContainerClassAddFieldCallback -> C_ContainerClassAddFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ColorSelectionChangePaletteWithScreenFunc :: (HasCallStack, MonadIO m, IsScreen a) => FunPtr C_ColorSelectionChangePaletteWithScreenFunc -> a -> [Color] -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ColorSelectionChangePaletteWithScreenFunc</a></tt>.
noColorSelectionChangePaletteWithScreenFunc :: Maybe ColorSelectionChangePaletteWithScreenFunc

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ColorSelectionChangePaletteWithScreenFunc :: MonadIO m => ColorSelectionChangePaletteWithScreenFunc -> m (GClosure C_ColorSelectionChangePaletteWithScreenFunc)

-- | Wrap a <a>ColorSelectionChangePaletteWithScreenFunc</a> into a
--   <a>C_ColorSelectionChangePaletteWithScreenFunc</a>.
wrap_ColorSelectionChangePaletteWithScreenFunc :: Maybe (Ptr (FunPtr C_ColorSelectionChangePaletteWithScreenFunc)) -> ColorSelectionChangePaletteWithScreenFunc -> C_ColorSelectionChangePaletteWithScreenFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ColorSelectionChangePaletteFunc :: (HasCallStack, MonadIO m) => FunPtr C_ColorSelectionChangePaletteFunc -> [Color] -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ColorSelectionChangePaletteFunc</a></tt>.
noColorSelectionChangePaletteFunc :: Maybe ColorSelectionChangePaletteFunc

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ColorSelectionChangePaletteFunc :: MonadIO m => ColorSelectionChangePaletteFunc -> m (GClosure C_ColorSelectionChangePaletteFunc)

-- | Wrap a <a>ColorSelectionChangePaletteFunc</a> into a
--   <a>C_ColorSelectionChangePaletteFunc</a>.
wrap_ColorSelectionChangePaletteFunc :: Maybe (Ptr (FunPtr C_ColorSelectionChangePaletteFunc)) -> ColorSelectionChangePaletteFunc -> C_ColorSelectionChangePaletteFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ClipboardURIReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardURIReceivedFunc -> a -> [Text] -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClipboardURIReceivedFunc</a></tt>.
noClipboardURIReceivedFunc :: Maybe ClipboardURIReceivedFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClipboardURIReceivedFunc_WithClosures</a></tt>.
noClipboardURIReceivedFunc_WithClosures :: Maybe ClipboardURIReceivedFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClipboardURIReceivedFunc :: ClipboardURIReceivedFunc -> ClipboardURIReceivedFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ClipboardURIReceivedFunc :: MonadIO m => ClipboardURIReceivedFunc -> m (GClosure C_ClipboardURIReceivedFunc)

-- | Wrap a <a>ClipboardURIReceivedFunc</a> into a
--   <a>C_ClipboardURIReceivedFunc</a>.
wrap_ClipboardURIReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardURIReceivedFunc)) -> ClipboardURIReceivedFunc_WithClosures -> C_ClipboardURIReceivedFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ClipboardTextReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardTextReceivedFunc -> a -> Maybe Text -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClipboardTextReceivedFunc</a></tt>.
noClipboardTextReceivedFunc :: Maybe ClipboardTextReceivedFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClipboardTextReceivedFunc_WithClosures</a></tt>.
noClipboardTextReceivedFunc_WithClosures :: Maybe ClipboardTextReceivedFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClipboardTextReceivedFunc :: ClipboardTextReceivedFunc -> ClipboardTextReceivedFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ClipboardTextReceivedFunc :: MonadIO m => ClipboardTextReceivedFunc -> m (GClosure C_ClipboardTextReceivedFunc)

-- | Wrap a <a>ClipboardTextReceivedFunc</a> into a
--   <a>C_ClipboardTextReceivedFunc</a>.
wrap_ClipboardTextReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardTextReceivedFunc)) -> ClipboardTextReceivedFunc_WithClosures -> C_ClipboardTextReceivedFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ClipboardTargetsReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardTargetsReceivedFunc -> a -> Maybe [Atom] -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClipboardTargetsReceivedFunc</a></tt>.
noClipboardTargetsReceivedFunc :: Maybe ClipboardTargetsReceivedFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClipboardTargetsReceivedFunc_WithClosures</a></tt>.
noClipboardTargetsReceivedFunc_WithClosures :: Maybe ClipboardTargetsReceivedFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClipboardTargetsReceivedFunc :: ClipboardTargetsReceivedFunc -> ClipboardTargetsReceivedFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ClipboardTargetsReceivedFunc :: MonadIO m => ClipboardTargetsReceivedFunc -> m (GClosure C_ClipboardTargetsReceivedFunc)

-- | Wrap a <a>ClipboardTargetsReceivedFunc</a> into a
--   <a>C_ClipboardTargetsReceivedFunc</a>.
wrap_ClipboardTargetsReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardTargetsReceivedFunc)) -> ClipboardTargetsReceivedFunc_WithClosures -> C_ClipboardTargetsReceivedFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ClipboardRichTextReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardRichTextReceivedFunc -> a -> Atom -> Maybe Text -> CSize -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClipboardRichTextReceivedFunc</a></tt>.
noClipboardRichTextReceivedFunc :: Maybe ClipboardRichTextReceivedFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClipboardRichTextReceivedFunc_WithClosures</a></tt>.
noClipboardRichTextReceivedFunc_WithClosures :: Maybe ClipboardRichTextReceivedFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClipboardRichTextReceivedFunc :: ClipboardRichTextReceivedFunc -> ClipboardRichTextReceivedFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ClipboardRichTextReceivedFunc :: MonadIO m => ClipboardRichTextReceivedFunc -> m (GClosure C_ClipboardRichTextReceivedFunc)

-- | Wrap a <a>ClipboardRichTextReceivedFunc</a> into a
--   <a>C_ClipboardRichTextReceivedFunc</a>.
wrap_ClipboardRichTextReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardRichTextReceivedFunc)) -> ClipboardRichTextReceivedFunc_WithClosures -> C_ClipboardRichTextReceivedFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ClipboardReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardReceivedFunc -> a -> SelectionData -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClipboardReceivedFunc</a></tt>.
noClipboardReceivedFunc :: Maybe ClipboardReceivedFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClipboardReceivedFunc_WithClosures</a></tt>.
noClipboardReceivedFunc_WithClosures :: Maybe ClipboardReceivedFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClipboardReceivedFunc :: ClipboardReceivedFunc -> ClipboardReceivedFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ClipboardReceivedFunc :: MonadIO m => ClipboardReceivedFunc -> m (GClosure C_ClipboardReceivedFunc)

-- | Wrap a <a>ClipboardReceivedFunc</a> into a
--   <a>C_ClipboardReceivedFunc</a>.
wrap_ClipboardReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardReceivedFunc)) -> ClipboardReceivedFunc_WithClosures -> C_ClipboardReceivedFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ClipboardImageReceivedFunc :: (HasCallStack, MonadIO m, IsClipboard a, IsPixbuf b) => FunPtr C_ClipboardImageReceivedFunc -> a -> Maybe b -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClipboardImageReceivedFunc</a></tt>.
noClipboardImageReceivedFunc :: Maybe ClipboardImageReceivedFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClipboardImageReceivedFunc_WithClosures</a></tt>.
noClipboardImageReceivedFunc_WithClosures :: Maybe ClipboardImageReceivedFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClipboardImageReceivedFunc :: ClipboardImageReceivedFunc -> ClipboardImageReceivedFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ClipboardImageReceivedFunc :: MonadIO m => ClipboardImageReceivedFunc -> m (GClosure C_ClipboardImageReceivedFunc)

-- | Wrap a <a>ClipboardImageReceivedFunc</a> into a
--   <a>C_ClipboardImageReceivedFunc</a>.
wrap_ClipboardImageReceivedFunc :: Maybe (Ptr (FunPtr C_ClipboardImageReceivedFunc)) -> ClipboardImageReceivedFunc_WithClosures -> C_ClipboardImageReceivedFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ClipboardGetFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardGetFunc -> a -> SelectionData -> Word32 -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClipboardGetFunc</a></tt>.
noClipboardGetFunc :: Maybe ClipboardGetFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClipboardGetFunc_WithClosures</a></tt>.
noClipboardGetFunc_WithClosures :: Maybe ClipboardGetFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClipboardGetFunc :: ClipboardGetFunc -> ClipboardGetFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ClipboardGetFunc :: MonadIO m => ClipboardGetFunc -> m (GClosure C_ClipboardGetFunc)

-- | Wrap a <a>ClipboardGetFunc</a> into a <a>C_ClipboardGetFunc</a>.
wrap_ClipboardGetFunc :: Maybe (Ptr (FunPtr C_ClipboardGetFunc)) -> ClipboardGetFunc_WithClosures -> C_ClipboardGetFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ClipboardClearFunc :: (HasCallStack, MonadIO m, IsClipboard a) => FunPtr C_ClipboardClearFunc -> a -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClipboardClearFunc</a></tt>.
noClipboardClearFunc :: Maybe ClipboardClearFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClipboardClearFunc_WithClosures</a></tt>.
noClipboardClearFunc_WithClosures :: Maybe ClipboardClearFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClipboardClearFunc :: ClipboardClearFunc -> ClipboardClearFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ClipboardClearFunc :: MonadIO m => ClipboardClearFunc -> m (GClosure C_ClipboardClearFunc)

-- | Wrap a <a>ClipboardClearFunc</a> into a <a>C_ClipboardClearFunc</a>.
wrap_ClipboardClearFunc :: Maybe (Ptr (FunPtr C_ClipboardClearFunc)) -> ClipboardClearFunc_WithClosures -> C_ClipboardClearFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_CellLayoutDataFunc :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b, IsTreeModel c) => FunPtr C_CellLayoutDataFunc -> a -> b -> c -> TreeIter -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CellLayoutDataFunc</a></tt>.
noCellLayoutDataFunc :: Maybe CellLayoutDataFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CellLayoutDataFunc_WithClosures</a></tt>.
noCellLayoutDataFunc_WithClosures :: Maybe CellLayoutDataFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_CellLayoutDataFunc :: CellLayoutDataFunc -> CellLayoutDataFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_CellLayoutDataFunc :: MonadIO m => CellLayoutDataFunc -> m (GClosure C_CellLayoutDataFunc)

-- | Wrap a <a>CellLayoutDataFunc</a> into a <a>C_CellLayoutDataFunc</a>.
wrap_CellLayoutDataFunc :: Maybe (Ptr (FunPtr C_CellLayoutDataFunc)) -> CellLayoutDataFunc_WithClosures -> C_CellLayoutDataFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_CellCallback :: (HasCallStack, MonadIO m, IsCellRenderer a) => FunPtr C_CellCallback -> a -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CellCallback</a></tt>.
noCellCallback :: Maybe CellCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CellCallback_WithClosures</a></tt>.
noCellCallback_WithClosures :: Maybe CellCallback_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_CellCallback :: CellCallback -> CellCallback_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_CellCallback :: MonadIO m => CellCallback -> m (GClosure C_CellCallback)

-- | Wrap a <a>CellCallback</a> into a <a>C_CellCallback</a>.
wrap_CellCallback :: Maybe (Ptr (FunPtr C_CellCallback)) -> CellCallback_WithClosures -> C_CellCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_CellAllocCallback :: (HasCallStack, MonadIO m, IsCellRenderer a) => FunPtr C_CellAllocCallback -> a -> Rectangle -> Rectangle -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CellAllocCallback</a></tt>.
noCellAllocCallback :: Maybe CellAllocCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CellAllocCallback_WithClosures</a></tt>.
noCellAllocCallback_WithClosures :: Maybe CellAllocCallback_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_CellAllocCallback :: CellAllocCallback -> CellAllocCallback_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_CellAllocCallback :: MonadIO m => CellAllocCallback -> m (GClosure C_CellAllocCallback)

-- | Wrap a <a>CellAllocCallback</a> into a <a>C_CellAllocCallback</a>.
wrap_CellAllocCallback :: Maybe (Ptr (FunPtr C_CellAllocCallback)) -> CellAllocCallback_WithClosures -> C_CellAllocCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>Callback_WithClosures</a></tt>.
noCallback_WithClosures :: Maybe Callback_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_Callback :: Callback -> Callback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_CalendarDetailFunc :: (HasCallStack, MonadIO m, IsCalendar a) => FunPtr C_CalendarDetailFunc -> a -> Word32 -> Word32 -> Word32 -> Ptr () -> m (Maybe Text)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CalendarDetailFunc</a></tt>.
noCalendarDetailFunc :: Maybe CalendarDetailFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CalendarDetailFunc_WithClosures</a></tt>.
noCalendarDetailFunc_WithClosures :: Maybe CalendarDetailFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_CalendarDetailFunc :: CalendarDetailFunc -> CalendarDetailFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_CalendarDetailFunc :: MonadIO m => CalendarDetailFunc -> m (GClosure C_CalendarDetailFunc)

-- | Wrap a <a>CalendarDetailFunc</a> into a <a>C_CalendarDetailFunc</a>.
wrap_CalendarDetailFunc :: Maybe (Ptr (FunPtr C_CalendarDetailFunc)) -> CalendarDetailFunc_WithClosures -> C_CalendarDetailFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_BuilderConnectFunc :: (HasCallStack, MonadIO m, IsBuilder a, IsObject b, IsObject c) => FunPtr C_BuilderConnectFunc -> a -> b -> Text -> Text -> Maybe c -> [ConnectFlags] -> Ptr () -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BuilderConnectFunc</a></tt>.
noBuilderConnectFunc :: Maybe BuilderConnectFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BuilderConnectFunc_WithClosures</a></tt>.
noBuilderConnectFunc_WithClosures :: Maybe BuilderConnectFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_BuilderConnectFunc :: BuilderConnectFunc -> BuilderConnectFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_BuilderConnectFunc :: MonadIO m => BuilderConnectFunc -> m (GClosure C_BuilderConnectFunc)

-- | Wrap a <a>BuilderConnectFunc</a> into a <a>C_BuilderConnectFunc</a>.
wrap_BuilderConnectFunc :: Maybe (Ptr (FunPtr C_BuilderConnectFunc)) -> BuilderConnectFunc_WithClosures -> C_BuilderConnectFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_AssistantPageFunc :: (HasCallStack, MonadIO m) => FunPtr C_AssistantPageFunc -> Int32 -> Ptr () -> m Int32

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>AssistantPageFunc</a></tt>.
noAssistantPageFunc :: Maybe AssistantPageFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>AssistantPageFunc_WithClosures</a></tt>.
noAssistantPageFunc_WithClosures :: Maybe AssistantPageFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_AssistantPageFunc :: AssistantPageFunc -> AssistantPageFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_AssistantPageFunc :: MonadIO m => AssistantPageFunc -> m (GClosure C_AssistantPageFunc)

-- | Wrap a <a>AssistantPageFunc</a> into a <a>C_AssistantPageFunc</a>.
wrap_AssistantPageFunc :: Maybe (Ptr (FunPtr C_AssistantPageFunc)) -> AssistantPageFunc_WithClosures -> C_AssistantPageFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ActionableInterfaceSetActionTargetValueFieldCallback :: (HasCallStack, MonadIO m, IsActionable a) => FunPtr C_ActionableInterfaceSetActionTargetValueFieldCallback -> a -> Maybe GVariant -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ActionableInterfaceSetActionTargetValueFieldCallback</a></tt>.
noActionableInterfaceSetActionTargetValueFieldCallback :: Maybe ActionableInterfaceSetActionTargetValueFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ActionableInterfaceSetActionTargetValueFieldCallback :: MonadIO m => ActionableInterfaceSetActionTargetValueFieldCallback -> m (GClosure C_ActionableInterfaceSetActionTargetValueFieldCallback)

-- | Wrap a <a>ActionableInterfaceSetActionTargetValueFieldCallback</a>
--   into a <a>C_ActionableInterfaceSetActionTargetValueFieldCallback</a>.
wrap_ActionableInterfaceSetActionTargetValueFieldCallback :: Maybe (Ptr (FunPtr C_ActionableInterfaceSetActionTargetValueFieldCallback)) -> ActionableInterfaceSetActionTargetValueFieldCallback -> C_ActionableInterfaceSetActionTargetValueFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ActionableInterfaceSetActionNameFieldCallback :: (HasCallStack, MonadIO m, IsActionable a) => FunPtr C_ActionableInterfaceSetActionNameFieldCallback -> a -> Maybe Text -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ActionableInterfaceSetActionNameFieldCallback</a></tt>.
noActionableInterfaceSetActionNameFieldCallback :: Maybe ActionableInterfaceSetActionNameFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ActionableInterfaceSetActionNameFieldCallback :: MonadIO m => ActionableInterfaceSetActionNameFieldCallback -> m (GClosure C_ActionableInterfaceSetActionNameFieldCallback)

-- | Wrap a <a>ActionableInterfaceSetActionNameFieldCallback</a> into a
--   <a>C_ActionableInterfaceSetActionNameFieldCallback</a>.
wrap_ActionableInterfaceSetActionNameFieldCallback :: Maybe (Ptr (FunPtr C_ActionableInterfaceSetActionNameFieldCallback)) -> ActionableInterfaceSetActionNameFieldCallback -> C_ActionableInterfaceSetActionNameFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ActionableInterfaceGetActionTargetValueFieldCallback :: (HasCallStack, MonadIO m, IsActionable a) => FunPtr C_ActionableInterfaceGetActionTargetValueFieldCallback -> a -> m GVariant

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ActionableInterfaceGetActionTargetValueFieldCallback</a></tt>.
noActionableInterfaceGetActionTargetValueFieldCallback :: Maybe ActionableInterfaceGetActionTargetValueFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ActionableInterfaceGetActionTargetValueFieldCallback :: MonadIO m => ActionableInterfaceGetActionTargetValueFieldCallback -> m (GClosure C_ActionableInterfaceGetActionTargetValueFieldCallback)

-- | Wrap a <a>ActionableInterfaceGetActionTargetValueFieldCallback</a>
--   into a <a>C_ActionableInterfaceGetActionTargetValueFieldCallback</a>.
wrap_ActionableInterfaceGetActionTargetValueFieldCallback :: Maybe (Ptr (FunPtr C_ActionableInterfaceGetActionTargetValueFieldCallback)) -> ActionableInterfaceGetActionTargetValueFieldCallback -> C_ActionableInterfaceGetActionTargetValueFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ActionableInterfaceGetActionNameFieldCallback :: (HasCallStack, MonadIO m, IsActionable a) => FunPtr C_ActionableInterfaceGetActionNameFieldCallback -> a -> m (Maybe Text)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ActionableInterfaceGetActionNameFieldCallback</a></tt>.
noActionableInterfaceGetActionNameFieldCallback :: Maybe ActionableInterfaceGetActionNameFieldCallback

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ActionableInterfaceGetActionNameFieldCallback :: MonadIO m => ActionableInterfaceGetActionNameFieldCallback -> m (GClosure C_ActionableInterfaceGetActionNameFieldCallback)

-- | Wrap a <a>ActionableInterfaceGetActionNameFieldCallback</a> into a
--   <a>C_ActionableInterfaceGetActionNameFieldCallback</a>.
wrap_ActionableInterfaceGetActionNameFieldCallback :: Maybe (Ptr (FunPtr C_ActionableInterfaceGetActionNameFieldCallback)) -> ActionableInterfaceGetActionNameFieldCallback -> C_ActionableInterfaceGetActionNameFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_AccelMapForeach :: (HasCallStack, MonadIO m) => FunPtr C_AccelMapForeach -> Ptr () -> Text -> Word32 -> [ModifierType] -> Bool -> m ()

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>AccelMapForeach</a></tt>.
noAccelMapForeach :: Maybe AccelMapForeach

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_AccelMapForeach :: MonadIO m => AccelMapForeach -> m (GClosure C_AccelMapForeach)

-- | Wrap a <a>AccelMapForeach</a> into a <a>C_AccelMapForeach</a>.
wrap_AccelMapForeach :: Maybe (Ptr (FunPtr C_AccelMapForeach)) -> AccelMapForeach -> C_AccelMapForeach

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_AccelGroupFindFunc :: (HasCallStack, MonadIO m) => FunPtr C_AccelGroupFindFunc -> AccelKey -> GClosure a -> Ptr () -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>AccelGroupFindFunc</a></tt>.
noAccelGroupFindFunc :: Maybe AccelGroupFindFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>AccelGroupFindFunc_WithClosures</a></tt>.
noAccelGroupFindFunc_WithClosures :: Maybe AccelGroupFindFunc_WithClosures

-- | A simple wrapper that ignores the closure arguments.
drop_closures_AccelGroupFindFunc :: AccelGroupFindFunc -> AccelGroupFindFunc_WithClosures

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_AccelGroupFindFunc :: MonadIO m => AccelGroupFindFunc -> m (GClosure C_AccelGroupFindFunc)

-- | Wrap a <a>AccelGroupFindFunc</a> into a <a>C_AccelGroupFindFunc</a>.
wrap_AccelGroupFindFunc :: Maybe (Ptr (FunPtr C_AccelGroupFindFunc)) -> AccelGroupFindFunc_WithClosures -> C_AccelGroupFindFunc

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_AccelGroupActivate :: (HasCallStack, MonadIO m, IsAccelGroup a, IsObject b) => FunPtr C_AccelGroupActivate -> a -> b -> Word32 -> [ModifierType] -> m Bool

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>AccelGroupActivate</a></tt>.
noAccelGroupActivate :: Maybe AccelGroupActivate

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_AccelGroupActivate :: MonadIO m => AccelGroupActivate -> m (GClosure C_AccelGroupActivate)

-- | Wrap a <a>AccelGroupActivate</a> into a <a>C_AccelGroupActivate</a>.
wrap_AccelGroupActivate :: Maybe (Ptr (FunPtr C_AccelGroupActivate)) -> AccelGroupActivate -> C_AccelGroupActivate

-- | Returns an empty widget path.
--   
--   <i>Since: 3.0</i>
widgetPathNew :: (HasCallStack, MonadIO m) => m WidgetPath

-- | Appends the data from <i><tt>widget</tt></i> to the widget hierarchy
--   represented by <i><tt>path</tt></i>. This function is a shortcut for
--   adding information from <i><tt>widget</tt></i> to the given
--   <i><tt>path</tt></i>. This includes setting the name or adding the
--   style classes from <i><tt>widget</tt></i>.
--   
--   <i>Since: 3.2</i>
widgetPathAppendForWidget :: (HasCallStack, MonadIO m, IsWidget a) => WidgetPath -> a -> m Int32

-- | Appends a widget type to the widget hierarchy represented by
--   <i><tt>path</tt></i>.
--   
--   <i>Since: 3.0</i>
widgetPathAppendType :: (HasCallStack, MonadIO m) => WidgetPath -> GType -> m Int32

-- | Appends a widget type with all its siblings to the widget hierarchy
--   represented by <i><tt>path</tt></i>. Using this function instead of
--   <a>widgetPathAppendType</a> will allow the CSS theming to use sibling
--   matches in selectors and apply :nth-<tt><i>child()</i></tt> pseudo
--   classes. In turn, it requires a lot more care in widget
--   implementations as widgets need to make sure to call
--   <a>widgetResetStyle</a> on all involved widgets when the
--   <i><tt>siblings</tt></i> path changes.
--   
--   <i>Since: 3.2</i>
widgetPathAppendWithSiblings :: (HasCallStack, MonadIO m) => WidgetPath -> WidgetPath -> Word32 -> m Int32

-- | Returns a copy of <i><tt>path</tt></i>
--   
--   <i>Since: 3.0</i>
widgetPathCopy :: (HasCallStack, MonadIO m) => WidgetPath -> m WidgetPath

-- | Decrements the reference count on <i><tt>path</tt></i>, freeing the
--   structure if the reference count reaches 0.
--   
--   <i>Since: 3.0</i>
widgetPathFree :: (HasCallStack, MonadIO m) => WidgetPath -> m ()

-- | Returns the topmost object type, that is, the object type this path is
--   representing.
--   
--   <i>Since: 3.0</i>
widgetPathGetObjectType :: (HasCallStack, MonadIO m) => WidgetPath -> m GType

-- | Returns <a>True</a> if any of the parents of the widget represented in
--   <i><tt>path</tt></i> is of type <i><tt>type</tt></i>, or any subtype
--   of it.
--   
--   <i>Since: 3.0</i>
widgetPathHasParent :: (HasCallStack, MonadIO m) => WidgetPath -> GType -> m Bool

-- | Returns <a>True</a> if the widget type represented by this path is
--   <i><tt>type</tt></i>, or a subtype of it.
--   
--   <i>Since: 3.0</i>
widgetPathIsType :: (HasCallStack, MonadIO m) => WidgetPath -> GType -> m Bool

-- | Adds the class <i><tt>name</tt></i> to the widget at position
--   <i><tt>pos</tt></i> in the hierarchy defined in <i><tt>path</tt></i>.
--   See <a>styleContextAddClass</a>.
--   
--   <i>Since: 3.0</i>
widgetPathIterAddClass :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> m ()

-- | Adds the region <i><tt>name</tt></i> to the widget at position
--   <i><tt>pos</tt></i> in the hierarchy defined in <i><tt>path</tt></i>.
--   See <a>styleContextAddRegion</a>.
--   
--   Region names must only contain lowercase letters and “-”, starting
--   always with a lowercase letter.
--   
--   <i>Since: 3.0</i>
widgetPathIterAddRegion :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> [RegionFlags] -> m ()

-- | Removes all classes from the widget at position <i><tt>pos</tt></i> in
--   the hierarchy defined in <i><tt>path</tt></i>.
--   
--   <i>Since: 3.0</i>
widgetPathIterClearClasses :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m ()

-- | Removes all regions from the widget at position <i><tt>pos</tt></i> in
--   the hierarchy defined in <i><tt>path</tt></i>.
--   
--   <i>Since: 3.0</i>
widgetPathIterClearRegions :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m ()

-- | Returns the name corresponding to the widget found at the position
--   <i><tt>pos</tt></i> in the widget hierarchy defined by
--   <i><tt>path</tt></i>
widgetPathIterGetName :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m (Maybe Text)

-- | Returns the object name that is at position <i><tt>pos</tt></i> in the
--   widget hierarchy defined in <i><tt>path</tt></i>.
--   
--   <i>Since: 3.20</i>
widgetPathIterGetObjectName :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m (Maybe Text)

-- | Returns the object <a>GType</a> that is at position
--   <i><tt>pos</tt></i> in the widget hierarchy defined in
--   <i><tt>path</tt></i>.
--   
--   <i>Since: 3.0</i>
widgetPathIterGetObjectType :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m GType

-- | Returns the index into the list of siblings for the element at
--   <i><tt>pos</tt></i> as returned by <a>widgetPathIterGetSiblings</a>.
--   If that function would return <a>Nothing</a> because the element at
--   <i><tt>pos</tt></i> has no siblings, this function will return 0.
widgetPathIterGetSiblingIndex :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m Word32

-- | Returns the list of siblings for the element at <i><tt>pos</tt></i>.
--   If the element was not added with siblings, <a>Nothing</a> is
--   returned.
widgetPathIterGetSiblings :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m WidgetPath

-- | Returns the state flags corresponding to the widget found at the
--   position <i><tt>pos</tt></i> in the widget hierarchy defined by
--   <i><tt>path</tt></i>
--   
--   <i>Since: 3.14</i>
widgetPathIterGetState :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m [StateFlags]

-- | Returns <a>True</a> if the widget at position <i><tt>pos</tt></i> has
--   the class <i><tt>name</tt></i> defined, <a>False</a> otherwise.
--   
--   <i>Since: 3.0</i>
widgetPathIterHasClass :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> m Bool

-- | Returns <a>True</a> if the widget at position <i><tt>pos</tt></i> has
--   the name <i><tt>name</tt></i>, <a>False</a> otherwise.
--   
--   <i>Since: 3.0</i>
widgetPathIterHasName :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> m Bool

-- | See <a>widgetPathIterHasClass</a>. This is a version that operates
--   with GQuarks.
--   
--   <i>Since: 3.0</i>
widgetPathIterHasQclass :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Word32 -> m Bool

-- | See <a>widgetPathIterHasName</a>. This is a version that operates on
--   <tt><i>GQuarks</i></tt>.
--   
--   <i>Since: 3.0</i>
widgetPathIterHasQname :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Word32 -> m Bool

-- | See <a>widgetPathIterHasRegion</a>. This is a version that operates
--   with GQuarks.
--   
--   <i>Since: 3.0</i>
widgetPathIterHasQregion :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Word32 -> m (Bool, [RegionFlags])

-- | Returns <a>True</a> if the widget at position <i><tt>pos</tt></i> has
--   the class <i><tt>name</tt></i> defined, <a>False</a> otherwise.
--   
--   <i>Since: 3.0</i>
widgetPathIterHasRegion :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> m (Bool, [RegionFlags])

-- | Returns a list with all the class names defined for the widget at
--   position <i><tt>pos</tt></i> in the hierarchy defined in
--   <i><tt>path</tt></i>.
--   
--   <i>Since: 3.0</i>
widgetPathIterListClasses :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m [Text]

-- | Returns a list with all the region names defined for the widget at
--   position <i><tt>pos</tt></i> in the hierarchy defined in
--   <i><tt>path</tt></i>.
--   
--   <i>Since: 3.0</i>
widgetPathIterListRegions :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> m [Text]

-- | Removes the class <i><tt>name</tt></i> from the widget at position
--   <i><tt>pos</tt></i> in the hierarchy defined in <i><tt>path</tt></i>.
--   
--   <i>Since: 3.0</i>
widgetPathIterRemoveClass :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> m ()

-- | Removes the region <i><tt>name</tt></i> from the widget at position
--   <i><tt>pos</tt></i> in the hierarchy defined in <i><tt>path</tt></i>.
--   
--   <i>Since: 3.0</i>
widgetPathIterRemoveRegion :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> m ()

-- | Sets the widget name for the widget found at position
--   <i><tt>pos</tt></i> in the widget hierarchy defined by
--   <i><tt>path</tt></i>.
--   
--   <i>Since: 3.0</i>
widgetPathIterSetName :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Text -> m ()

-- | Sets the object name for a given position in the widget hierarchy
--   defined by <i><tt>path</tt></i>.
--   
--   When set, the object name overrides the object type when matching CSS.
--   
--   <i>Since: 3.20</i>
widgetPathIterSetObjectName :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> Maybe Text -> m ()

-- | Sets the object type for a given position in the widget hierarchy
--   defined by <i><tt>path</tt></i>.
--   
--   <i>Since: 3.0</i>
widgetPathIterSetObjectType :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> GType -> m ()

-- | Sets the widget name for the widget found at position
--   <i><tt>pos</tt></i> in the widget hierarchy defined by
--   <i><tt>path</tt></i>.
--   
--   If you want to update just a single state flag, you need to do this
--   manually, as this function updates all state flags.
--   
--   <h2>Setting a flag</h2>
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   gtk_widget_path_iter_set_state (path, pos, gtk_widget_path_iter_get_state (path, pos) | flag);
--   </pre>
--   
--   <h2>Unsetting a flag</h2>
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   gtk_widget_path_iter_set_state (path, pos, gtk_widget_path_iter_get_state (path, pos) &amp; ~flag);
--   </pre>
--   
--   <i>Since: 3.14</i>
widgetPathIterSetState :: (HasCallStack, MonadIO m) => WidgetPath -> Int32 -> [StateFlags] -> m ()

-- | Returns the number of <a>Widget</a> <tt><i>GTypes</i></tt> between the
--   represented widget and its topmost container.
--   
--   <i>Since: 3.0</i>
widgetPathLength :: (HasCallStack, MonadIO m) => WidgetPath -> m Int32

-- | Prepends a widget type to the widget hierachy represented by
--   <i><tt>path</tt></i>.
--   
--   <i>Since: 3.0</i>
widgetPathPrependType :: (HasCallStack, MonadIO m) => WidgetPath -> GType -> m ()

-- | Increments the reference count on <i><tt>path</tt></i>.
--   
--   <i>Since: 3.2</i>
widgetPathRef :: (HasCallStack, MonadIO m) => WidgetPath -> m WidgetPath

-- | Dumps the widget path into a string representation. It tries to match
--   the CSS style as closely as possible (Note that there might be paths
--   that cannot be represented in CSS).
--   
--   The main use of this code is for debugging purposes, so that you can
--   <tt><i>g_print()</i></tt> the path or dump it in a gdb session.
--   
--   <i>Since: 3.2</i>
widgetPathToString :: (HasCallStack, MonadIO m) => WidgetPath -> m Text

-- | Decrements the reference count on <i><tt>path</tt></i>, freeing the
--   structure if the reference count reaches 0.
--   
--   <i>Since: 3.2</i>
widgetPathUnref :: (HasCallStack, MonadIO m) => WidgetPath -> m ()

-- | Construct a <a>TextIter</a> struct initialized to zero.
newZeroTextIter :: MonadIO m => m TextIter

-- | Assigns the value of <i><tt>other</tt></i> to <i><tt>iter</tt></i>.
--   This function is not useful in applications, because iterators can be
--   assigned with <tt>GtkTextIter i = j;</tt>. The function is used by
--   language bindings.
--   
--   <i>Since: 3.2</i>
textIterAssign :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m ()

-- | Moves backward by one character offset. Returns <a>True</a> if
--   movement was possible; if <i><tt>iter</tt></i> was the first in the
--   buffer (character offset 0), <a>textIterBackwardChar</a> returns
--   <a>False</a> for convenience when writing loops.
textIterBackwardChar :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves <i><tt>count</tt></i> characters backward, if possible (if
--   <i><tt>count</tt></i> would move past the start or end of the buffer,
--   moves to the start or end of the buffer). The return value indicates
--   whether the iterator moved onto a dereferenceable position; if the
--   iterator didn’t move, or moved onto the end iterator, then
--   <a>False</a> is returned. If <i><tt>count</tt></i> is 0, the function
--   does nothing and returns <a>False</a>.
textIterBackwardChars :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Like <a>textIterForwardCursorPosition</a>, but moves backward.
textIterBackwardCursorPosition :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves up to <i><tt>count</tt></i> cursor positions. See
--   <a>textIterForwardCursorPosition</a> for details.
textIterBackwardCursorPositions :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Same as <a>textIterForwardFindChar</a>, but goes backward from
--   <i><tt>iter</tt></i>.
textIterBackwardFindChar :: (HasCallStack, MonadIO m) => TextIter -> TextCharPredicate -> Maybe TextIter -> m Bool

-- | Moves <i><tt>iter</tt></i> to the start of the previous line. Returns
--   <a>True</a> if <i><tt>iter</tt></i> could be moved; i.e. if
--   <i><tt>iter</tt></i> was at character offset 0, this function returns
--   <a>False</a>. Therefore if <i><tt>iter</tt></i> was already on line 0,
--   but not at the start of the line, <i><tt>iter</tt></i> is snapped to
--   the start of the line and the function returns <a>True</a>. (Note that
--   this implies that in a loop calling this function, the line number may
--   not change on every iteration, if your first iteration is on line 0.)
textIterBackwardLine :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves <i><tt>count</tt></i> lines backward, if possible (if
--   <i><tt>count</tt></i> would move past the start or end of the buffer,
--   moves to the start or end of the buffer). The return value indicates
--   whether the iterator moved onto a dereferenceable position; if the
--   iterator didn’t move, or moved onto the end iterator, then
--   <a>False</a> is returned. If <i><tt>count</tt></i> is 0, the function
--   does nothing and returns <a>False</a>. If <i><tt>count</tt></i> is
--   negative, moves forward by 0 - <i><tt>count</tt></i> lines.
textIterBackwardLines :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Same as <a>textIterForwardSearch</a>, but moves backward.
--   
--   <i><tt>matchEnd</tt></i> will never be set to a <a>TextIter</a>
--   located after <i><tt>iter</tt></i>, even if there is a possible
--   <i><tt>matchStart</tt></i> before or at <i><tt>iter</tt></i>.
textIterBackwardSearch :: (HasCallStack, MonadIO m) => TextIter -> Text -> [TextSearchFlags] -> Maybe TextIter -> m (Bool, TextIter, TextIter)

-- | Moves backward to the previous sentence start; if <i><tt>iter</tt></i>
--   is already at the start of a sentence, moves backward to the next one.
--   Sentence boundaries are determined by Pango and should be correct for
--   nearly any language (if not, the correct fix would be to the Pango
--   text boundary algorithms).
textIterBackwardSentenceStart :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Calls <a>textIterBackwardSentenceStart</a> up to <i><tt>count</tt></i>
--   times, or until it returns <a>False</a>. If <i><tt>count</tt></i> is
--   negative, moves forward instead of backward.
textIterBackwardSentenceStarts :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves backward to the next toggle (on or off) of the <a>TextTag</a>
--   <i><tt>tag</tt></i>, or to the next toggle of any tag if
--   <i><tt>tag</tt></i> is <a>Nothing</a>. If no matching tag toggles are
--   found, returns <a>False</a>, otherwise <a>True</a>. Does not return
--   toggles located at <i><tt>iter</tt></i>, only toggles before
--   <i><tt>iter</tt></i>. Sets <i><tt>iter</tt></i> to the location of the
--   toggle, or the start of the buffer if no toggle is found.
textIterBackwardToTagToggle :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

-- | Moves <i><tt>iter</tt></i> forward to the previous visible cursor
--   position. See <a>textIterBackwardCursorPosition</a> for details.
--   
--   <i>Since: 2.4</i>
textIterBackwardVisibleCursorPosition :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves up to <i><tt>count</tt></i> visible cursor positions. See
--   <a>textIterBackwardCursorPosition</a> for details.
--   
--   <i>Since: 2.4</i>
textIterBackwardVisibleCursorPositions :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves <i><tt>iter</tt></i> to the start of the previous visible line.
--   Returns <a>True</a> if <i><tt>iter</tt></i> could be moved; i.e. if
--   <i><tt>iter</tt></i> was at character offset 0, this function returns
--   <a>False</a>. Therefore if <i><tt>iter</tt></i> was already on line 0,
--   but not at the start of the line, <i><tt>iter</tt></i> is snapped to
--   the start of the line and the function returns <a>True</a>. (Note that
--   this implies that in a loop calling this function, the line number may
--   not change on every iteration, if your first iteration is on line 0.)
--   
--   <i>Since: 2.8</i>
textIterBackwardVisibleLine :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves <i><tt>count</tt></i> visible lines backward, if possible (if
--   <i><tt>count</tt></i> would move past the start or end of the buffer,
--   moves to the start or end of the buffer). The return value indicates
--   whether the iterator moved onto a dereferenceable position; if the
--   iterator didn’t move, or moved onto the end iterator, then
--   <a>False</a> is returned. If <i><tt>count</tt></i> is 0, the function
--   does nothing and returns <a>False</a>. If <i><tt>count</tt></i> is
--   negative, moves forward by 0 - <i><tt>count</tt></i> lines.
--   
--   <i>Since: 2.8</i>
textIterBackwardVisibleLines :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves backward to the previous visible word start. (If
--   <i><tt>iter</tt></i> is currently on a word start, moves backward to
--   the next one after that.) Word breaks are determined by Pango and
--   should be correct for nearly any language (if not, the correct fix
--   would be to the Pango word break algorithms).
--   
--   <i>Since: 2.4</i>
textIterBackwardVisibleWordStart :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Calls <a>textIterBackwardVisibleWordStart</a> up to
--   <i><tt>count</tt></i> times.
--   
--   <i>Since: 2.4</i>
textIterBackwardVisibleWordStarts :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves backward to the previous word start. (If <i><tt>iter</tt></i> is
--   currently on a word start, moves backward to the next one after that.)
--   Word breaks are determined by Pango and should be correct for nearly
--   any language (if not, the correct fix would be to the Pango word break
--   algorithms).
textIterBackwardWordStart :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Calls <a>textIterBackwardWordStart</a> up to <i><tt>count</tt></i>
--   times.
textIterBackwardWordStarts :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Returns <a>True</a> if <i><tt>tag</tt></i> is toggled on at exactly
--   this point. If <i><tt>tag</tt></i> is <a>Nothing</a>, returns
--   <a>True</a> if any tag is toggled on at this point.
--   
--   Note that if <a>textIterBeginsTag</a> returns <a>True</a>, it means
--   that <i><tt>iter</tt></i> is at the beginning of the tagged range, and
--   that the character at <i><tt>iter</tt></i> is inside the tagged range.
--   In other words, unlike <a>textIterEndsTag</a>, if
--   <a>textIterBeginsTag</a> returns <a>True</a>, <a>textIterHasTag</a>
--   will also return <a>True</a> for the same parameters.
textIterBeginsTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

-- | Considering the default editability of the buffer, and tags that
--   affect editability, determines whether text inserted at
--   <i><tt>iter</tt></i> would be editable. If text inserted at
--   <i><tt>iter</tt></i> would be editable then the user should be allowed
--   to insert text at <i><tt>iter</tt></i>.
--   <a>textBufferInsertInteractive</a> uses this function to decide
--   whether insertions are allowed at a given position.
textIterCanInsert :: (HasCallStack, MonadIO m) => TextIter -> Bool -> m Bool

-- | A <tt><i>qsort()</i></tt>-style function that returns negative if
--   <i><tt>lhs</tt></i> is less than <i><tt>rhs</tt></i>, positive if
--   <i><tt>lhs</tt></i> is greater than <i><tt>rhs</tt></i>, and 0 if
--   they’re equal. Ordering is in character offset order, i.e. the first
--   character in the buffer is less than the second character in the
--   buffer.
textIterCompare :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m Int32

-- | Creates a dynamically-allocated copy of an iterator. This function is
--   not useful in applications, because iterators can be copied with a
--   simple assignment (<tt>GtkTextIter i = j;</tt>). The function is used
--   by language bindings.
textIterCopy :: (HasCallStack, MonadIO m) => TextIter -> m TextIter

-- | Returns whether the character at <i><tt>iter</tt></i> is within an
--   editable region of text. Non-editable text is “locked” and can’t be
--   changed by the user via <a>TextView</a>. This function is simply a
--   convenience wrapper around <a>textIterGetAttributes</a>. If no tags
--   applied to this text affect editability,
--   <i><tt>defaultSetting</tt></i> will be returned.
--   
--   You don’t want to use this function to decide whether text can be
--   inserted at <i><tt>iter</tt></i>, because for insertion you don’t want
--   to know whether the char at <i><tt>iter</tt></i> is inside an editable
--   range, you want to know whether a new character inserted at
--   <i><tt>iter</tt></i> would be inside an editable range. Use
--   <a>textIterCanInsert</a> to handle this case.
textIterEditable :: (HasCallStack, MonadIO m) => TextIter -> Bool -> m Bool

-- | Returns <a>True</a> if <i><tt>iter</tt></i> points to the start of the
--   paragraph delimiter characters for a line (delimiters will be either a
--   newline, a carriage return, a carriage return followed by a newline,
--   or a Unicode paragraph separator character). Note that an iterator
--   pointing to the \n of a \r\n pair will not be counted as the end of a
--   line, the line ends before the \r. The end iterator is considered to
--   be at the end of a line, even though there are no paragraph delimiter
--   chars there.
textIterEndsLine :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Determines whether <i><tt>iter</tt></i> ends a sentence. Sentence
--   boundaries are determined by Pango and should be correct for nearly
--   any language (if not, the correct fix would be to the Pango text
--   boundary algorithms).
textIterEndsSentence :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Returns <a>True</a> if <i><tt>tag</tt></i> is toggled off at exactly
--   this point. If <i><tt>tag</tt></i> is <a>Nothing</a>, returns
--   <a>True</a> if any tag is toggled off at this point.
--   
--   Note that if <a>textIterEndsTag</a> returns <a>True</a>, it means that
--   <i><tt>iter</tt></i> is at the end of the tagged range, but that the
--   character at <i><tt>iter</tt></i> is outside the tagged range. In
--   other words, unlike <a>textIterStartsTag</a>, if
--   <a>textIterEndsTag</a> returns <a>True</a>, <a>textIterHasTag</a> will
--   return <a>False</a> for the same parameters.
textIterEndsTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

-- | Determines whether <i><tt>iter</tt></i> ends a natural-language word.
--   Word breaks are determined by Pango and should be correct for nearly
--   any language (if not, the correct fix would be to the Pango word break
--   algorithms).
textIterEndsWord :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Tests whether two iterators are equal, using the fastest possible
--   mechanism. This function is very fast; you can expect it to perform
--   better than e.g. getting the character offset for each iterator and
--   comparing the offsets yourself. Also, it’s a bit faster than
--   <a>textIterCompare</a>.
textIterEqual :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m Bool

-- | Moves <i><tt>iter</tt></i> forward by one character offset. Note that
--   images embedded in the buffer occupy 1 character slot, so
--   <a>textIterForwardChar</a> may actually move onto an image instead of
--   a character, if you have images in your buffer. If
--   <i><tt>iter</tt></i> is the end iterator or one character before it,
--   <i><tt>iter</tt></i> will now point at the end iterator, and
--   <a>textIterForwardChar</a> returns <a>False</a> for convenience when
--   writing loops.
textIterForwardChar :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves <i><tt>count</tt></i> characters if possible (if
--   <i><tt>count</tt></i> would move past the start or end of the buffer,
--   moves to the start or end of the buffer). The return value indicates
--   whether the new position of <i><tt>iter</tt></i> is different from its
--   original position, and dereferenceable (the last iterator in the
--   buffer is not dereferenceable). If <i><tt>count</tt></i> is 0, the
--   function does nothing and returns <a>False</a>.
textIterForwardChars :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves <i><tt>iter</tt></i> forward by a single cursor position. Cursor
--   positions are (unsurprisingly) positions where the cursor can appear.
--   Perhaps surprisingly, there may not be a cursor position between all
--   characters. The most common example for European languages would be a
--   carriage return/newline sequence. For some Unicode characters, the
--   equivalent of say the letter “a” with an accent mark will be
--   represented as two characters, first the letter then a "combining
--   mark" that causes the accent to be rendered; so the cursor can’t go
--   between those two characters. See also the <a>LogAttr</a>-struct and
--   <a>break</a> function.
textIterForwardCursorPosition :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves up to <i><tt>count</tt></i> cursor positions. See
--   <a>textIterForwardCursorPosition</a> for details.
textIterForwardCursorPositions :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Advances <i><tt>iter</tt></i>, calling <i><tt>pred</tt></i> on each
--   character. If <i><tt>pred</tt></i> returns <a>True</a>, returns
--   <a>True</a> and stops scanning. If <i><tt>pred</tt></i> never returns
--   <a>True</a>, <i><tt>iter</tt></i> is set to <i><tt>limit</tt></i> if
--   <i><tt>limit</tt></i> is non-<a>Nothing</a>, otherwise to the end
--   iterator.
textIterForwardFindChar :: (HasCallStack, MonadIO m) => TextIter -> TextCharPredicate -> Maybe TextIter -> m Bool

-- | Moves <i><tt>iter</tt></i> to the start of the next line. If the iter
--   is already on the last line of the buffer, moves the iter to the end
--   of the current line. If after the operation, the iter is at the end of
--   the buffer and not dereferencable, returns <a>False</a>. Otherwise,
--   returns <a>True</a>.
textIterForwardLine :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves <i><tt>count</tt></i> lines forward, if possible (if
--   <i><tt>count</tt></i> would move past the start or end of the buffer,
--   moves to the start or end of the buffer). The return value indicates
--   whether the iterator moved onto a dereferenceable position; if the
--   iterator didn’t move, or moved onto the end iterator, then
--   <a>False</a> is returned. If <i><tt>count</tt></i> is 0, the function
--   does nothing and returns <a>False</a>. If <i><tt>count</tt></i> is
--   negative, moves backward by 0 - <i><tt>count</tt></i> lines.
textIterForwardLines :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Searches forward for <i><tt>str</tt></i>. Any match is returned by
--   setting <i><tt>matchStart</tt></i> to the first character of the match
--   and <i><tt>matchEnd</tt></i> to the first character after the match.
--   The search will not continue past <i><tt>limit</tt></i>. Note that a
--   search is a linear or O(n) operation, so you may wish to use
--   <i><tt>limit</tt></i> to avoid locking up your UI on large buffers.
--   
--   <i><tt>matchStart</tt></i> will never be set to a <a>TextIter</a>
--   located before <i><tt>iter</tt></i>, even if there is a possible
--   <i><tt>matchEnd</tt></i> after or at <i><tt>iter</tt></i>.
textIterForwardSearch :: (HasCallStack, MonadIO m) => TextIter -> Text -> [TextSearchFlags] -> Maybe TextIter -> m (Bool, TextIter, TextIter)

-- | Moves forward to the next sentence end. (If <i><tt>iter</tt></i> is at
--   the end of a sentence, moves to the next end of sentence.) Sentence
--   boundaries are determined by Pango and should be correct for nearly
--   any language (if not, the correct fix would be to the Pango text
--   boundary algorithms).
textIterForwardSentenceEnd :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Calls <a>textIterForwardSentenceEnd</a> <i><tt>count</tt></i> times
--   (or until <a>textIterForwardSentenceEnd</a> returns <a>False</a>). If
--   <i><tt>count</tt></i> is negative, moves backward instead of forward.
textIterForwardSentenceEnds :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves <i><tt>iter</tt></i> forward to the “end iterator,” which points
--   one past the last valid character in the buffer.
--   <a>textIterGetChar</a> called on the end iterator returns 0, which is
--   convenient for writing loops.
textIterForwardToEnd :: (HasCallStack, MonadIO m) => TextIter -> m ()

-- | Moves the iterator to point to the paragraph delimiter characters,
--   which will be either a newline, a carriage return, a carriage
--   return/newline in sequence, or the Unicode paragraph separator
--   character. If the iterator is already at the paragraph delimiter
--   characters, moves to the paragraph delimiter characters for the next
--   line. If <i><tt>iter</tt></i> is on the last line in the buffer, which
--   does not end in paragraph delimiters, moves to the end iterator (end
--   of the last line), and returns <a>False</a>.
textIterForwardToLineEnd :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves forward to the next toggle (on or off) of the <a>TextTag</a>
--   <i><tt>tag</tt></i>, or to the next toggle of any tag if
--   <i><tt>tag</tt></i> is <a>Nothing</a>. If no matching tag toggles are
--   found, returns <a>False</a>, otherwise <a>True</a>. Does not return
--   toggles located at <i><tt>iter</tt></i>, only toggles after
--   <i><tt>iter</tt></i>. Sets <i><tt>iter</tt></i> to the location of the
--   toggle, or to the end of the buffer if no toggle is found.
textIterForwardToTagToggle :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

-- | Moves <i><tt>iter</tt></i> forward to the next visible cursor
--   position. See <a>textIterForwardCursorPosition</a> for details.
--   
--   <i>Since: 2.4</i>
textIterForwardVisibleCursorPosition :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves up to <i><tt>count</tt></i> visible cursor positions. See
--   <a>textIterForwardCursorPosition</a> for details.
--   
--   <i>Since: 2.4</i>
textIterForwardVisibleCursorPositions :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves <i><tt>iter</tt></i> to the start of the next visible line.
--   Returns <a>True</a> if there was a next line to move to, and
--   <a>False</a> if <i><tt>iter</tt></i> was simply moved to the end of
--   the buffer and is now not dereferenceable, or if <i><tt>iter</tt></i>
--   was already at the end of the buffer.
--   
--   <i>Since: 2.8</i>
textIterForwardVisibleLine :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves <i><tt>count</tt></i> visible lines forward, if possible (if
--   <i><tt>count</tt></i> would move past the start or end of the buffer,
--   moves to the start or end of the buffer). The return value indicates
--   whether the iterator moved onto a dereferenceable position; if the
--   iterator didn’t move, or moved onto the end iterator, then
--   <a>False</a> is returned. If <i><tt>count</tt></i> is 0, the function
--   does nothing and returns <a>False</a>. If <i><tt>count</tt></i> is
--   negative, moves backward by 0 - <i><tt>count</tt></i> lines.
--   
--   <i>Since: 2.8</i>
textIterForwardVisibleLines :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves forward to the next visible word end. (If <i><tt>iter</tt></i>
--   is currently on a word end, moves forward to the next one after that.)
--   Word breaks are determined by Pango and should be correct for nearly
--   any language (if not, the correct fix would be to the Pango word break
--   algorithms).
--   
--   <i>Since: 2.4</i>
textIterForwardVisibleWordEnd :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Calls <a>textIterForwardVisibleWordEnd</a> up to <i><tt>count</tt></i>
--   times.
--   
--   <i>Since: 2.4</i>
textIterForwardVisibleWordEnds :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves forward to the next word end. (If <i><tt>iter</tt></i> is
--   currently on a word end, moves forward to the next one after that.)
--   Word breaks are determined by Pango and should be correct for nearly
--   any language (if not, the correct fix would be to the Pango word break
--   algorithms).
textIterForwardWordEnd :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Calls <a>textIterForwardWordEnd</a> up to <i><tt>count</tt></i> times.
textIterForwardWordEnds :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Free an iterator allocated on the heap. This function is intended for
--   use in language bindings, and is not especially useful for
--   applications, because iterators can simply be allocated on the stack.
textIterFree :: (HasCallStack, MonadIO m) => TextIter -> m ()

-- | Returns the <a>TextBuffer</a> this iterator is associated with.
textIterGetBuffer :: (HasCallStack, MonadIO m) => TextIter -> m TextBuffer

-- | Returns the number of bytes in the line containing
--   <i><tt>iter</tt></i>, including the paragraph delimiters.
textIterGetBytesInLine :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | Returns the number of characters in the line containing
--   <i><tt>iter</tt></i>, including the paragraph delimiters.
textIterGetCharsInLine :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | If the location at <i><tt>iter</tt></i> contains a child anchor, the
--   anchor is returned (with no new reference count added). Otherwise,
--   <a>Nothing</a> is returned.
textIterGetChildAnchor :: (HasCallStack, MonadIO m) => TextIter -> m TextChildAnchor

-- | A convenience wrapper around <a>textIterGetAttributes</a>, which
--   returns the language in effect at <i><tt>iter</tt></i>. If no tags
--   affecting language apply to <i><tt>iter</tt></i>, the return value is
--   identical to that of <a>getDefaultLanguage</a>.
textIterGetLanguage :: (HasCallStack, MonadIO m) => TextIter -> m Language

-- | Returns the line number containing the iterator. Lines in a
--   <a>TextBuffer</a> are numbered beginning with 0 for the first line in
--   the buffer.
textIterGetLine :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | Returns the byte index of the iterator, counting from the start of a
--   newline-terminated line. Remember that <a>TextBuffer</a> encodes text
--   in UTF-8, and that characters can require a variable number of bytes
--   to represent.
textIterGetLineIndex :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | Returns the character offset of the iterator, counting from the start
--   of a newline-terminated line. The first character on the line has
--   offset 0.
textIterGetLineOffset :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | Returns a list of all <a>TextMark</a> at this location. Because marks
--   are not iterable (they don’t take up any "space" in the buffer, they
--   are just marks in between iterable locations), multiple marks can
--   exist in the same place. The returned list is not in any meaningful
--   order.
textIterGetMarks :: (HasCallStack, MonadIO m) => TextIter -> m [TextMark]

-- | Returns the character offset of an iterator. Each character in a
--   <a>TextBuffer</a> has an offset, starting with 0 for the first
--   character in the buffer. Use <a>textBufferGetIterAtOffset</a> to
--   convert an offset back into an iterator.
textIterGetOffset :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | If the element at <i><tt>iter</tt></i> is a pixbuf, the pixbuf is
--   returned (with no new reference count added). Otherwise,
--   <a>Nothing</a> is returned.
textIterGetPixbuf :: (HasCallStack, MonadIO m) => TextIter -> m Pixbuf

-- | Returns the text in the given range. A “slice” is an array of
--   characters encoded in UTF-8 format, including the Unicode “unknown”
--   character 0xFFFC for iterable non-character elements in the buffer,
--   such as images. Because images are encoded in the slice, byte and
--   character offsets in the returned array will correspond to byte
--   offsets in the text buffer. Note that 0xFFFC can occur in normal text
--   as well, so it is not a reliable indicator that a pixbuf or widget is
--   in the buffer.
textIterGetSlice :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m Text

-- | Returns a list of tags that apply to <i><tt>iter</tt></i>, in
--   ascending order of priority (highest-priority tags are last). The
--   <a>TextTag</a> in the list don’t have a reference added, but you have
--   to free the list itself.
textIterGetTags :: (HasCallStack, MonadIO m) => TextIter -> m [TextTag]

-- | Returns text in the given range. If the range contains non-text
--   elements such as images, the character and byte offsets in the
--   returned string will not correspond to character and byte offsets in
--   the buffer. If you want offsets to correspond, see
--   <a>textIterGetSlice</a>.
textIterGetText :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m Text

-- | Returns a list of <a>TextTag</a> that are toggled on or off at this
--   point. (If <i><tt>toggledOn</tt></i> is <a>True</a>, the list contains
--   tags that are toggled on.) If a tag is toggled on at
--   <i><tt>iter</tt></i>, then some non-empty range of characters
--   following <i><tt>iter</tt></i> has that tag applied to it. If a tag is
--   toggled off, then some non-empty range following <i><tt>iter</tt></i>
--   does not have the tag applied to it.
textIterGetToggledTags :: (HasCallStack, MonadIO m) => TextIter -> Bool -> m [TextTag]

-- | Returns the number of bytes from the start of the line to the given
--   <i><tt>iter</tt></i>, not counting bytes that are invisible due to
--   tags with the “invisible” flag toggled on.
textIterGetVisibleLineIndex :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | Returns the offset in characters from the start of the line to the
--   given <i><tt>iter</tt></i>, not counting characters that are invisible
--   due to tags with the “invisible” flag toggled on.
textIterGetVisibleLineOffset :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | Like <a>textIterGetSlice</a>, but invisible text is not included.
--   Invisible text is usually invisible because a <a>TextTag</a> with the
--   “invisible” attribute turned on has been applied to it.
textIterGetVisibleSlice :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m Text

-- | Like <a>textIterGetText</a>, but invisible text is not included.
--   Invisible text is usually invisible because a <a>TextTag</a> with the
--   “invisible” attribute turned on has been applied to it.
textIterGetVisibleText :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m Text

-- | Returns <a>True</a> if <i><tt>iter</tt></i> points to a character that
--   is part of a range tagged with <i><tt>tag</tt></i>. See also
--   <a>textIterStartsTag</a> and <a>textIterEndsTag</a>.
textIterHasTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> a -> m Bool

-- | Checks whether <i><tt>iter</tt></i> falls in the range
--   [<i><tt>start</tt></i>, <i><tt>end</tt></i>). <i><tt>start</tt></i>
--   and <i><tt>end</tt></i> must be in ascending order.
textIterInRange :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> TextIter -> m Bool

-- | Determines whether <i><tt>iter</tt></i> is inside a sentence (as
--   opposed to in between two sentences, e.g. after a period and before
--   the first letter of the next sentence). Sentence boundaries are
--   determined by Pango and should be correct for nearly any language (if
--   not, the correct fix would be to the Pango text boundary algorithms).
textIterInsideSentence :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Determines whether the character pointed by <i><tt>iter</tt></i> is
--   part of a natural-language word (as opposed to say inside some
--   whitespace). Word breaks are determined by Pango and should be correct
--   for nearly any language (if not, the correct fix would be to the Pango
--   word break algorithms).
--   
--   Note that if <a>textIterStartsWord</a> returns <a>True</a>, then this
--   function returns <a>True</a> too, since <i><tt>iter</tt></i> points to
--   the first character of the word.
textIterInsideWord :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | See <a>textIterForwardCursorPosition</a> or <a>LogAttr</a> or
--   <a>break</a> for details on what a cursor position is.
textIterIsCursorPosition :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Returns <a>True</a> if <i><tt>iter</tt></i> is the end iterator, i.e.
--   one past the last dereferenceable iterator in the buffer.
--   <a>textIterIsEnd</a> is the most efficient way to check whether an
--   iterator is the end iterator.
textIterIsEnd :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Returns <a>True</a> if <i><tt>iter</tt></i> is the first iterator in
--   the buffer, that is if <i><tt>iter</tt></i> has a character offset of
--   0.
textIterIsStart :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Swaps the value of <i><tt>first</tt></i> and <i><tt>second</tt></i> if
--   <i><tt>second</tt></i> comes before <i><tt>first</tt></i> in the
--   buffer. That is, ensures that <i><tt>first</tt></i> and
--   <i><tt>second</tt></i> are in sequence. Most text buffer functions
--   that take a range call this automatically on your behalf, so there’s
--   no real reason to call it yourself in those cases. There are some
--   exceptions, such as <a>textIterInRange</a>, that expect a pre-sorted
--   range.
textIterOrder :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m ()

-- | Moves iterator <i><tt>iter</tt></i> to the start of the line
--   <i><tt>lineNumber</tt></i>. If <i><tt>lineNumber</tt></i> is negative
--   or larger than the number of lines in the buffer, moves
--   <i><tt>iter</tt></i> to the start of the last line in the buffer.
textIterSetLine :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m ()

-- | Same as <a>textIterSetLineOffset</a>, but works with a byte index. The
--   given byte index must be at the start of a character, it can’t be in
--   the middle of a UTF-8 encoded character.
textIterSetLineIndex :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m ()

-- | Moves <i><tt>iter</tt></i> within a line, to a new character (not
--   byte) offset. The given character offset must be less than or equal to
--   the number of characters in the line; if equal, <i><tt>iter</tt></i>
--   moves to the start of the next line. See <a>textIterSetLineIndex</a>
--   if you have a byte index rather than a character offset.
textIterSetLineOffset :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m ()

-- | Sets <i><tt>iter</tt></i> to point to <i><tt>charOffset</tt></i>.
--   <i><tt>charOffset</tt></i> counts from the start of the entire text
--   buffer, starting with 0.
textIterSetOffset :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m ()

-- | Like <a>textIterSetLineIndex</a>, but the index is in visible bytes,
--   i.e. text with a tag making it invisible is not counted in the index.
textIterSetVisibleLineIndex :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m ()

-- | Like <a>textIterSetLineOffset</a>, but the offset is in visible
--   characters, i.e. text with a tag making it invisible is not counted in
--   the offset.
textIterSetVisibleLineOffset :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m ()

-- | Returns <a>True</a> if <i><tt>iter</tt></i> begins a paragraph, i.e.
--   if <a>textIterGetLineOffset</a> would return 0. However this function
--   is potentially more efficient than <a>textIterGetLineOffset</a>
--   because it doesn’t have to compute the offset, it just has to see
--   whether it’s 0.
textIterStartsLine :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Determines whether <i><tt>iter</tt></i> begins a sentence. Sentence
--   boundaries are determined by Pango and should be correct for nearly
--   any language (if not, the correct fix would be to the Pango text
--   boundary algorithms).
textIterStartsSentence :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Returns <a>True</a> if <i><tt>tag</tt></i> is toggled on at exactly
--   this point. If <i><tt>tag</tt></i> is <a>Nothing</a>, returns
--   <a>True</a> if any tag is toggled on at this point.
--   
--   Note that if <a>textIterStartsTag</a> returns <a>True</a>, it means
--   that <i><tt>iter</tt></i> is at the beginning of the tagged range, and
--   that the character at <i><tt>iter</tt></i> is inside the tagged range.
--   In other words, unlike <a>textIterEndsTag</a>, if
--   <a>textIterStartsTag</a> returns <a>True</a>, <a>textIterHasTag</a>
--   will also return <a>True</a> for the same parameters.
--   
--   <i>Since: 3.20</i>
textIterStartsTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

-- | Determines whether <i><tt>iter</tt></i> begins a natural-language
--   word. Word breaks are determined by Pango and should be correct for
--   nearly any language (if not, the correct fix would be to the Pango
--   word break algorithms).
textIterStartsWord :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | This is equivalent to (<a>textIterStartsTag</a> ||
--   <a>textIterEndsTag</a>), i.e. it tells you whether a range with
--   <i><tt>tag</tt></i> applied to it begins or ends at
--   <i><tt>iter</tt></i>.
textIterTogglesTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

-- | Creates a new <a>TargetList</a> from an array of <a>TargetEntry</a>.
targetListNew :: (HasCallStack, MonadIO m) => Maybe [TargetEntry] -> m TargetList

-- | Appends another target to a <a>TargetList</a>.
targetListAdd :: (HasCallStack, MonadIO m) => TargetList -> Atom -> Word32 -> Word32 -> m ()

-- | Prepends a table of <a>TargetEntry</a> to a target list.
targetListAddTable :: (HasCallStack, MonadIO m) => TargetList -> [TargetEntry] -> m ()

-- | Looks up a given target in a <a>TargetList</a>.
targetListFind :: (HasCallStack, MonadIO m) => TargetList -> Atom -> m (Bool, Word32)

-- | Increases the reference count of a <a>TargetList</a> by one.
targetListRef :: (HasCallStack, MonadIO m) => TargetList -> m TargetList

-- | Removes a target from a target list.
targetListRemove :: (HasCallStack, MonadIO m) => TargetList -> Atom -> m ()

-- | Decreases the reference count of a <a>TargetList</a> by one. If the
--   resulting reference count is zero, frees the list.
targetListUnref :: (HasCallStack, MonadIO m) => TargetList -> m ()

-- | Creates a symbolic color by modifying the relative alpha value of
--   <i><tt>color</tt></i>. A factor &lt; 1.0 would resolve to a more
--   transparent color, while &gt; 1.0 would resolve to a more opaque
--   color.
--   
--   <i>Since: 3.0</i>
symbolicColorNewAlpha :: (HasCallStack, MonadIO m) => SymbolicColor -> Double -> m SymbolicColor

-- | Creates a symbolic color pointing to a literal color.
--   
--   <i>Since: 3.0</i>
symbolicColorNewLiteral :: (HasCallStack, MonadIO m) => RGBA -> m SymbolicColor

-- | Creates a symbolic color defined as a mix of another two colors. a mix
--   factor of 0 would resolve to <i><tt>color1</tt></i>, while a factor of
--   1 would resolve to <i><tt>color2</tt></i>.
--   
--   <i>Since: 3.0</i>
symbolicColorNewMix :: (HasCallStack, MonadIO m) => SymbolicColor -> SymbolicColor -> Double -> m SymbolicColor

-- | Creates a symbolic color pointing to an unresolved named color. See
--   <a>styleContextLookupColor</a> and <a>stylePropertiesLookupColor</a>.
--   
--   <i>Since: 3.0</i>
symbolicColorNewName :: (HasCallStack, MonadIO m) => Text -> m SymbolicColor

-- | Creates a symbolic color defined as a shade of another color. A factor
--   &gt; 1.0 would resolve to a brighter color, while &lt; 1.0 would
--   resolve to a darker color.
--   
--   <i>Since: 3.0</i>
symbolicColorNewShade :: (HasCallStack, MonadIO m) => SymbolicColor -> Double -> m SymbolicColor

-- | Creates a symbolic color based on the current win32 theme.
--   
--   Note that while this call is available on all platforms the actual
--   value returned is not reliable on non-win32 platforms.
--   
--   <i>Since: 3.4</i>
symbolicColorNewWin32 :: (HasCallStack, MonadIO m) => Text -> Int32 -> m SymbolicColor

-- | Increases the reference count of <i><tt>color</tt></i>
--   
--   <i>Since: 3.0</i>
symbolicColorRef :: (HasCallStack, MonadIO m) => SymbolicColor -> m SymbolicColor

-- | If <i><tt>color</tt></i> is resolvable, <i><tt>resolvedColor</tt></i>
--   will be filled in with the resolved color, and <a>True</a> will be
--   returned. Generally, if <i><tt>color</tt></i> can’t be resolved, it is
--   due to it being defined on top of a named color that doesn’t exist in
--   <i><tt>props</tt></i>.
--   
--   When <i><tt>props</tt></i> is <a>Nothing</a>, resolving of named
--   colors will fail, so if your <i><tt>color</tt></i> is or references
--   such a color, this function will return <a>False</a>.
--   
--   <i>Since: 3.0</i>
symbolicColorResolve :: (HasCallStack, MonadIO m, IsStyleProperties a) => SymbolicColor -> Maybe a -> m (Bool, RGBA)

-- | Converts the given <i><tt>color</tt></i> to a string representation.
--   This is useful both for debugging and for serialization of strings.
--   The format of the string may change between different versions of GTK,
--   but it is guaranteed that the GTK css parser is able to read the
--   string and create the same symbolic color from it.
symbolicColorToString :: (HasCallStack, MonadIO m) => SymbolicColor -> m Text

-- | Decreases the reference count of <i><tt>color</tt></i>, freeing its
--   memory if the reference count reaches 0.
--   
--   <i>Since: 3.0</i>
symbolicColorUnref :: (HasCallStack, MonadIO m) => SymbolicColor -> m ()

-- | Makes a copy of a <a>SelectionData</a>-struct and its data.
selectionDataCopy :: (HasCallStack, MonadIO m) => SelectionData -> m SelectionData

-- | Retrieves the data type of the selection.
--   
--   <i>Since: 2.14</i>
selectionDataGetDataType :: (HasCallStack, MonadIO m) => SelectionData -> m Atom

-- | Retrieves the raw data of the selection along with its length.
--   
--   <i>Since: 3.0</i>
selectionDataGetData :: (HasCallStack, MonadIO m) => SelectionData -> m ByteString

-- | Retrieves the display of the selection.
--   
--   <i>Since: 2.14</i>
selectionDataGetDisplay :: (HasCallStack, MonadIO m) => SelectionData -> m Display

-- | Retrieves the format of the selection.
--   
--   <i>Since: 2.14</i>
selectionDataGetFormat :: (HasCallStack, MonadIO m) => SelectionData -> m Int32

-- | Retrieves the length of the raw data of the selection.
--   
--   <i>Since: 2.14</i>
selectionDataGetLength :: (HasCallStack, MonadIO m) => SelectionData -> m Int32

-- | Gets the contents of the selection data as a <a>Pixbuf</a>.
--   
--   <i>Since: 2.6</i>
selectionDataGetPixbuf :: (HasCallStack, MonadIO m) => SelectionData -> m (Maybe Pixbuf)

-- | Retrieves the selection <a>Atom</a> of the selection data.
--   
--   <i>Since: 2.16</i>
selectionDataGetSelection :: (HasCallStack, MonadIO m) => SelectionData -> m Atom

-- | Retrieves the target of the selection.
--   
--   <i>Since: 2.14</i>
selectionDataGetTarget :: (HasCallStack, MonadIO m) => SelectionData -> m Atom

-- | Gets the contents of <i><tt>selectionData</tt></i> as an array of
--   targets. This can be used to interpret the results of getting the
--   standard TARGETS target that is always supplied for any selection.
selectionDataGetTargets :: (HasCallStack, MonadIO m) => SelectionData -> m (Bool, [Atom])

-- | Gets the contents of the selection data as a UTF-8 string.
selectionDataGetText :: (HasCallStack, MonadIO m) => SelectionData -> m (Maybe Text)

-- | Gets the contents of the selection data as array of URIs.
--   
--   Since 3.24.37, this may involve using the FileTransfer portal to send
--   files between sandboxed apps.
--   
--   <i>Since: 2.6</i>
selectionDataGetUris :: (HasCallStack, MonadIO m) => SelectionData -> m [Text]

-- | Sets the contents of the selection from a <a>Pixbuf</a> The pixbuf is
--   converted to the form determined by
--   <i><tt>selectionData</tt></i>-&gt;target.
--   
--   <i>Since: 2.6</i>
selectionDataSetPixbuf :: (HasCallStack, MonadIO m, IsPixbuf a) => SelectionData -> a -> m Bool

-- | Sets the contents of the selection from a list of URIs. The string is
--   converted to the form determined by
--   <i><tt>selectionData</tt></i>-&gt;target.
--   
--   Since 3.24.37, this may involve using the FileTransfer portal to send
--   files between sandboxed apps.
--   
--   <i>Since: 2.6</i>
selectionDataSetUris :: (HasCallStack, MonadIO m) => SelectionData -> [Text] -> m Bool

-- | Given a <a>SelectionData</a> object holding a list of targets,
--   determines if any of the targets in <i><tt>targets</tt></i> can be
--   used to provide a <a>Pixbuf</a>.
--   
--   <i>Since: 2.6</i>
selectionDataTargetsIncludeImage :: (HasCallStack, MonadIO m) => SelectionData -> Bool -> m Bool

-- | Given a <a>SelectionData</a> object holding a list of targets,
--   determines if any of the targets in <i><tt>targets</tt></i> can be
--   used to provide rich text.
--   
--   <i>Since: 2.10</i>
selectionDataTargetsIncludeRichText :: (HasCallStack, MonadIO m, IsTextBuffer a) => SelectionData -> a -> m Bool

-- | Given a <a>SelectionData</a> object holding a list of targets,
--   determines if any of the targets in <i><tt>targets</tt></i> can be
--   used to provide text.
selectionDataTargetsIncludeText :: (HasCallStack, MonadIO m) => SelectionData -> m Bool

-- | Given a <a>SelectionData</a> object holding a list of targets,
--   determines if any of the targets in <i><tt>targets</tt></i> can be
--   used to provide a list or URIs.
--   
--   <i>Since: 2.10</i>
selectionDataTargetsIncludeUri :: (HasCallStack, MonadIO m) => SelectionData -> m Bool

-- | Creates a new <a>IconSet</a>. A <a>IconSet</a> represents a single
--   icon in various sizes and widget states. It can provide a
--   <a>Pixbuf</a> for a given size and state on request, and automatically
--   caches some of the rendered <a>Pixbuf</a> objects.
--   
--   Normally you would use <a>widgetRenderIconPixbuf</a> instead of using
--   <a>IconSet</a> directly. The one case where you’d use <a>IconSet</a>
--   is to create application-specific icon sets to place in a
--   <a>IconFactory</a>.
iconSetNew :: (HasCallStack, MonadIO m) => m IconSet

-- | Copies <i><tt>iconSet</tt></i> by value.
iconSetCopy :: (HasCallStack, MonadIO m) => IconSet -> m IconSet

-- | Obtains a list of icon sizes this icon set can render. The returned
--   array must be freed with <a>free</a>.
iconSetGetSizes :: (HasCallStack, MonadIO m) => IconSet -> m [Int32]

-- | Increments the reference count on <i><tt>iconSet</tt></i>.
iconSetRef :: (HasCallStack, MonadIO m) => IconSet -> m IconSet

-- | Renders an icon using <a>styleRenderIcon</a>. In most cases,
--   <a>widgetRenderIcon</a> is better, since it automatically provides
--   most of the arguments from the current widget settings. This function
--   never returns <a>Nothing</a>; if the icon can’t be rendered (perhaps
--   because an image file fails to load), a default "missing image" icon
--   will be returned instead.
iconSetRenderIcon :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => IconSet -> Maybe a -> TextDirection -> StateType -> Int32 -> Maybe b -> Maybe Text -> m Pixbuf

-- | Renders an icon using <a>renderIconPixbuf</a>. In most cases,
--   <a>widgetRenderIconPixbuf</a> is better, since it automatically
--   provides most of the arguments from the current widget settings. This
--   function never returns <a>Nothing</a>; if the icon can’t be rendered
--   (perhaps because an image file fails to load), a default "missing
--   image" icon will be returned instead.
--   
--   <i>Since: 3.0</i>
iconSetRenderIconPixbuf :: (HasCallStack, MonadIO m, IsStyleContext a) => IconSet -> a -> Int32 -> m Pixbuf

-- | Renders an icon using <a>renderIconPixbuf</a> and converts it to a
--   cairo surface.
--   
--   This function never returns <a>Nothing</a>; if the icon can’t be
--   rendered (perhaps because an image file fails to load), a default
--   "missing image" icon will be returned instead.
--   
--   <i>Since: 3.10</i>
iconSetRenderIconSurface :: (HasCallStack, MonadIO m, IsStyleContext a, IsWindow b) => IconSet -> a -> Int32 -> Int32 -> Maybe b -> m Surface

-- | Decrements the reference count on <i><tt>iconSet</tt></i>, and frees
--   memory if the reference count reaches 0.
iconSetUnref :: (HasCallStack, MonadIO m) => IconSet -> m ()

-- | Creates a new <a>WindowGroup</a> object. Grabs added with
--   <a>widgetGrabAdd</a> only affect windows within the same
--   <a>WindowGroup</a>.
windowGroupNew :: (HasCallStack, MonadIO m) => m WindowGroup

-- | Adds a window to a <a>WindowGroup</a>.
windowGroupAddWindow :: (HasCallStack, MonadIO m, IsWindowGroup a, IsWindow b) => a -> b -> m ()

-- | Returns the current grab widget for <i><tt>device</tt></i>, or
--   <a>Nothing</a> if none.
--   
--   <i>Since: 3.0</i>
windowGroupGetCurrentDeviceGrab :: (HasCallStack, MonadIO m, IsWindowGroup a, IsDevice b) => a -> b -> m (Maybe Widget)

-- | Gets the current grab widget of the given group, see
--   <a>widgetGrabAdd</a>.
--   
--   <i>Since: 2.22</i>
windowGroupGetCurrentGrab :: (HasCallStack, MonadIO m, IsWindowGroup a) => a -> m Widget

-- | Returns a list of the <tt><i>GtkWindows</i></tt> that belong to
--   <i><tt>windowGroup</tt></i>.
--   
--   <i>Since: 2.14</i>
windowGroupListWindows :: (HasCallStack, MonadIO m, IsWindowGroup a) => a -> m [Window]

-- | Removes a window from a <a>WindowGroup</a>.
windowGroupRemoveWindow :: (HasCallStack, MonadIO m, IsWindowGroup a, IsWindow b) => a -> b -> m ()

-- | Connect a signal handler for the <a>activateDefault</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> window #activateDefault callback
--   </pre>
onWindowActivateDefault :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowActivateDefaultCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateDefault</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> window #activateDefault callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWindowActivateDefault :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowActivateDefaultCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateFocus</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> window #activateFocus callback
--   </pre>
onWindowActivateFocus :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowActivateFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateFocus</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> window #activateFocus callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWindowActivateFocus :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowActivateFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>enableDebugging</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> window #enableDebugging callback
--   </pre>
onWindowEnableDebugging :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowEnableDebuggingCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>enableDebugging</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> window #enableDebugging callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWindowEnableDebugging :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowEnableDebuggingCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>keysChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> window #keysChanged callback
--   </pre>
onWindowKeysChanged :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowKeysChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>keysChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> window #keysChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWindowKeysChanged :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowKeysChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>setFocus</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> window #setFocus callback
--   </pre>
onWindowSetFocus :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowSetFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>setFocus</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> window #setFocus callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWindowSetFocus :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowSetFocusCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>accept-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #acceptFocus
--   </pre>
getWindowAcceptFocus :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>accept-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #acceptFocus <a>:=</a> value ]
--   </pre>
setWindowAcceptFocus :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accept-focus</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWindowAcceptFocus :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>application</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #application
--   </pre>
getWindowApplication :: (MonadIO m, IsWindow o) => o -> m (Maybe Application)

-- | Set the value of the “<tt>application</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #application <a>:=</a> value ]
--   </pre>
setWindowApplication :: (MonadIO m, IsWindow o, IsApplication a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>application</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWindowApplication :: (IsWindow o, MonadIO m, IsApplication a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>application</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #application
--   </pre>
clearWindowApplication :: (MonadIO m, IsWindow o) => o -> m ()

-- | Get the value of the “<tt>attached-to</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #attachedTo
--   </pre>
getWindowAttachedTo :: (MonadIO m, IsWindow o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>attached-to</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #attachedTo <a>:=</a> value ]
--   </pre>
setWindowAttachedTo :: (MonadIO m, IsWindow o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>attached-to</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWindowAttachedTo :: (IsWindow o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>attached-to</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #attachedTo
--   </pre>
clearWindowAttachedTo :: (MonadIO m, IsWindow o) => o -> m ()

-- | Get the value of the “<tt>decorated</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #decorated
--   </pre>
getWindowDecorated :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>decorated</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #decorated <a>:=</a> value ]
--   </pre>
setWindowDecorated :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>decorated</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWindowDecorated :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>default-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #defaultHeight
--   </pre>
getWindowDefaultHeight :: (MonadIO m, IsWindow o) => o -> m Int32

-- | Set the value of the “<tt>default-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #defaultHeight <a>:=</a> value ]
--   </pre>
setWindowDefaultHeight :: (MonadIO m, IsWindow o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>default-height</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWindowDefaultHeight :: (IsWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>default-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #defaultWidth
--   </pre>
getWindowDefaultWidth :: (MonadIO m, IsWindow o) => o -> m Int32

-- | Set the value of the “<tt>default-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #defaultWidth <a>:=</a> value ]
--   </pre>
setWindowDefaultWidth :: (MonadIO m, IsWindow o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>default-width</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWindowDefaultWidth :: (IsWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>deletable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #deletable
--   </pre>
getWindowDeletable :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>deletable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #deletable <a>:=</a> value ]
--   </pre>
setWindowDeletable :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>deletable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWindowDeletable :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>destroy-with-parent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #destroyWithParent
--   </pre>
getWindowDestroyWithParent :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>destroy-with-parent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #destroyWithParent <a>:=</a> value ]
--   </pre>
setWindowDestroyWithParent :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>destroy-with-parent</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructWindowDestroyWithParent :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>focus-on-map</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #focusOnMap
--   </pre>
getWindowFocusOnMap :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>focus-on-map</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #focusOnMap <a>:=</a> value ]
--   </pre>
setWindowFocusOnMap :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>focus-on-map</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWindowFocusOnMap :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>focus-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #focusVisible
--   </pre>
getWindowFocusVisible :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>focus-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #focusVisible <a>:=</a> value ]
--   </pre>
setWindowFocusVisible :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>focus-visible</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWindowFocusVisible :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gravity</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #gravity
--   </pre>
getWindowGravity :: (MonadIO m, IsWindow o) => o -> m Gravity

-- | Set the value of the “<tt>gravity</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #gravity <a>:=</a> value ]
--   </pre>
setWindowGravity :: (MonadIO m, IsWindow o) => o -> Gravity -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gravity</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWindowGravity :: (IsWindow o, MonadIO m) => Gravity -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-resize-grip</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #hasResizeGrip
--   </pre>
getWindowHasResizeGrip :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>has-resize-grip</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #hasResizeGrip <a>:=</a> value ]
--   </pre>
setWindowHasResizeGrip :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-resize-grip</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWindowHasResizeGrip :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-toplevel-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #hasToplevelFocus
--   </pre>
getWindowHasToplevelFocus :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Get the value of the “<tt>hide-titlebar-when-maximized</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #hideTitlebarWhenMaximized
--   </pre>
getWindowHideTitlebarWhenMaximized :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>hide-titlebar-when-maximized</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #hideTitlebarWhenMaximized <a>:=</a> value ]
--   </pre>
setWindowHideTitlebarWhenMaximized :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hide-titlebar-when-maximized</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructWindowHideTitlebarWhenMaximized :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #icon
--   </pre>
getWindowIcon :: (MonadIO m, IsWindow o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “<tt>icon</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #icon <a>:=</a> value ]
--   </pre>
setWindowIcon :: (MonadIO m, IsWindow o, IsPixbuf a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWindowIcon :: (IsWindow o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>icon</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #icon
--   </pre>
clearWindowIcon :: (MonadIO m, IsWindow o) => o -> m ()

-- | Get the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #iconName
--   </pre>
getWindowIconName :: (MonadIO m, IsWindow o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #iconName <a>:=</a> value ]
--   </pre>
setWindowIconName :: (MonadIO m, IsWindow o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWindowIconName :: (IsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>icon-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #iconName
--   </pre>
clearWindowIconName :: (MonadIO m, IsWindow o) => o -> m ()

-- | Get the value of the “<tt>is-active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #isActive
--   </pre>
getWindowIsActive :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Get the value of the “<tt>is-maximized</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #isMaximized
--   </pre>
getWindowIsMaximized :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Get the value of the “<tt>mnemonics-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #mnemonicsVisible
--   </pre>
getWindowMnemonicsVisible :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>mnemonics-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #mnemonicsVisible <a>:=</a> value ]
--   </pre>
setWindowMnemonicsVisible :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>mnemonics-visible</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWindowMnemonicsVisible :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #modal
--   </pre>
getWindowModal :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #modal <a>:=</a> value ]
--   </pre>
setWindowModal :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>modal</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWindowModal :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>resizable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #resizable
--   </pre>
getWindowResizable :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>resizable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #resizable <a>:=</a> value ]
--   </pre>
setWindowResizable :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>resizable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWindowResizable :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>resize-grip-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #resizeGripVisible
--   </pre>
getWindowResizeGripVisible :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Get the value of the “<tt>role</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #role
--   </pre>
getWindowRole :: (MonadIO m, IsWindow o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>role</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #role <a>:=</a> value ]
--   </pre>
setWindowRole :: (MonadIO m, IsWindow o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>role</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWindowRole :: (IsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>screen</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #screen
--   </pre>
getWindowScreen :: (MonadIO m, IsWindow o) => o -> m Screen

-- | Set the value of the “<tt>screen</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #screen <a>:=</a> value ]
--   </pre>
setWindowScreen :: (MonadIO m, IsWindow o, IsScreen a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>screen</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWindowScreen :: (IsWindow o, MonadIO m, IsScreen a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>skip-pager-hint</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #skipPagerHint
--   </pre>
getWindowSkipPagerHint :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>skip-pager-hint</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #skipPagerHint <a>:=</a> value ]
--   </pre>
setWindowSkipPagerHint :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>skip-pager-hint</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWindowSkipPagerHint :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>skip-taskbar-hint</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #skipTaskbarHint
--   </pre>
getWindowSkipTaskbarHint :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>skip-taskbar-hint</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #skipTaskbarHint <a>:=</a> value ]
--   </pre>
setWindowSkipTaskbarHint :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>skip-taskbar-hint</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWindowSkipTaskbarHint :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Set the value of the “<tt>startup-id</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #startupId <a>:=</a> value ]
--   </pre>
setWindowStartupId :: (MonadIO m, IsWindow o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>startup-id</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWindowStartupId :: (IsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #title
--   </pre>
getWindowTitle :: (MonadIO m, IsWindow o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #title <a>:=</a> value ]
--   </pre>
setWindowTitle :: (MonadIO m, IsWindow o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWindowTitle :: (IsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>transient-for</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #transientFor
--   </pre>
getWindowTransientFor :: (MonadIO m, IsWindow o) => o -> m (Maybe Window)

-- | Set the value of the “<tt>transient-for</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #transientFor <a>:=</a> value ]
--   </pre>
setWindowTransientFor :: (MonadIO m, IsWindow o, IsWindow a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>transient-for</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWindowTransientFor :: (IsWindow o, MonadIO m, IsWindow a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>transient-for</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #transientFor
--   </pre>
clearWindowTransientFor :: (MonadIO m, IsWindow o) => o -> m ()

-- | Get the value of the “<tt>type</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #type
--   </pre>
getWindowType :: (MonadIO m, IsWindow o) => o -> m WindowType

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>type</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWindowType :: (IsWindow o, MonadIO m) => WindowType -> m (GValueConstruct o)

-- | Get the value of the “<tt>type-hint</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #typeHint
--   </pre>
getWindowTypeHint :: (MonadIO m, IsWindow o) => o -> m WindowTypeHint

-- | Set the value of the “<tt>type-hint</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #typeHint <a>:=</a> value ]
--   </pre>
setWindowTypeHint :: (MonadIO m, IsWindow o) => o -> WindowTypeHint -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>type-hint</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWindowTypeHint :: (IsWindow o, MonadIO m) => WindowTypeHint -> m (GValueConstruct o)

-- | Get the value of the “<tt>urgency-hint</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #urgencyHint
--   </pre>
getWindowUrgencyHint :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>urgency-hint</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #urgencyHint <a>:=</a> value ]
--   </pre>
setWindowUrgencyHint :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>urgency-hint</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWindowUrgencyHint :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>window-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #windowPosition
--   </pre>
getWindowWindowPosition :: (MonadIO m, IsWindow o) => o -> m WindowPosition

-- | Set the value of the “<tt>window-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #windowPosition <a>:=</a> value ]
--   </pre>
setWindowWindowPosition :: (MonadIO m, IsWindow o) => o -> WindowPosition -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>window-position</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWindowWindowPosition :: (IsWindow o, MonadIO m) => WindowPosition -> m (GValueConstruct o)

-- | Activates the current focused widget within the window.
windowActivateFocus :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Activates mnemonics and accelerators for this <a>Window</a>. This is
--   normally called by the default <a>key_press_event</a> handler for
--   toplevel windows, however in some cases it may be useful to call this
--   directly when overriding the standard key handling for a toplevel
--   window.
--   
--   <i>Since: 2.4</i>
windowActivateKey :: (HasCallStack, MonadIO m, IsWindow a) => a -> EventKey -> m Bool

-- | Adds a mnemonic to this window.
windowAddMnemonic :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Word32 -> b -> m ()

-- | Requests that the window is closed, similar to what happens when a
--   window manager close button is clicked.
--   
--   This function can be used with close buttons in custom titlebars.
--   
--   <i>Since: 3.10</i>
windowClose :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Gets the <a>Application</a> associated with the window (if any).
--   
--   <i>Since: 3.0</i>
windowGetApplication :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Application)

-- | Fetches the attach widget for this window. See
--   <a>windowSetAttachedTo</a>.
--   
--   <i>Since: 3.4</i>
windowGetAttachedTo :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Widget)

-- | Returns whether the window has been set to have decorations such as a
--   title bar via <a>windowSetDecorated</a>.
windowGetDecorated :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Gets the default size of the window. A value of -1 for the width or
--   height indicates that a default size has not been explicitly set for
--   that dimension, so the “natural” size of the window will be used.
windowGetDefaultSize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Int32, Int32)

-- | Returns the default widget for <i><tt>window</tt></i>. See
--   <a>windowSetDefault</a> for more details.
--   
--   <i>Since: 2.14</i>
windowGetDefaultWidget :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Widget)

-- | Returns whether the window has been set to have a close button via
--   <a>windowSetDeletable</a>.
--   
--   <i>Since: 2.10</i>
windowGetDeletable :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns whether the window will be destroyed with its transient
--   parent. See gtk_window_set_destroy_with_parent ().
windowGetDestroyWithParent :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Gets the value set by <a>windowSetGravity</a>.
windowGetGravity :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Gravity

-- | Determines whether the window may have a resize grip.
--   
--   <i>Since: 3.0</i>
windowGetHasResizeGrip :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns whether the window has requested to have its titlebar hidden
--   when maximized. See gtk_window_set_hide_titlebar_when_maximized ().
--   
--   <i>Since: 3.4</i>
windowGetHideTitlebarWhenMaximized :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Gets the value set by <a>windowSetIcon</a> (or if you've called
--   <a>windowSetIconList</a>, gets the first icon in the icon list).
windowGetIcon :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Pixbuf)

-- | Retrieves the list of icons set by <a>windowSetIconList</a>. The list
--   is copied, but the reference count on each member won’t be
--   incremented.
windowGetIconList :: (HasCallStack, MonadIO m, IsWindow a) => a -> m [Pixbuf]

-- | Returns the name of the themed icon for the window, see
--   <a>windowSetIconName</a>.
--   
--   <i>Since: 2.6</i>
windowGetIconName :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Text)

-- | Returns the mnemonic modifier for this window. See
--   <a>windowSetMnemonicModifier</a>.
windowGetMnemonicModifier :: (HasCallStack, MonadIO m, IsWindow a) => a -> m [ModifierType]

-- | Gets the value of the <a>Window:mnemonicsVisible</a> property.
--   
--   <i>Since: 2.20</i>
windowGetMnemonicsVisible :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns whether the window is modal. See <a>windowSetModal</a>.
windowGetModal :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Fetches the requested opacity for this window. See
--   <a>windowSetOpacity</a>.
--   
--   <i>Since: 2.12</i>
windowGetOpacity :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Double

-- | Gets the value set by <a>windowSetResizable</a>.
windowGetResizable :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | If a window has a resize grip, this will retrieve the grip position,
--   width and height into the specified <a>Rectangle</a>.
--   
--   <i>Since: 3.0</i>
windowGetResizeGripArea :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Bool, Rectangle)

-- | Returns the role of the window. See <a>windowSetRole</a> for further
--   explanation.
windowGetRole :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Text)

-- | Obtains the current size of <i><tt>window</tt></i>.
--   
--   If <i><tt>window</tt></i> is not visible on screen, this function
--   return the size GTK+ will suggest to the [window
--   manager][gtk-X11-arch] for the initial window size (but this is not
--   reliably the same as the size the window manager will actually
--   select). See: <a>windowSetDefaultSize</a>.
--   
--   Depending on the windowing system and the window manager constraints,
--   the size returned by this function may not match the size set using
--   <a>windowResize</a>; additionally, since <a>windowResize</a> may be
--   implemented as an asynchronous operation, GTK+ cannot guarantee in any
--   way that this code:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   // width and height are set elsewhere
--   gtk_window_resize (window, width, height);
--   
--   int new_width, new_height;
--   gtk_window_get_size (window, &amp;new_width, &amp;new_height);
--   </pre>
--   
--   will result in <tt>new_width</tt> and <tt>new_height</tt> matching
--   <tt>width</tt> and <tt>height</tt>, respectively.
--   
--   This function will return the logical size of the <a>Window</a>,
--   excluding the widgets used in client side decorations; there is,
--   however, no guarantee that the result will be completely accurate
--   because client side decoration may include widgets that depend on the
--   user preferences and that may not be visibile at the time you call
--   this function.
--   
--   The dimensions returned by this function are suitable for being stored
--   across sessions; use <a>windowSetDefaultSize</a> to restore them when
--   before showing the window.
--   
--   To avoid potential race conditions, you should only call this function
--   in response to a size change notification, for instance inside a
--   handler for the <a>Widget::sizeAllocate</a> signal, or inside a
--   handler for the <a>Widget::configureEvent</a> signal:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   static void
--   on_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
--   {
--     int new_width, new_height;
--   
--     gtk_window_get_size (GTK_WINDOW (widget), &amp;new_width, &amp;new_height);
--   
--     ...
--   }
--   </pre>
--   
--   Note that, if you connect to the <a>Widget::sizeAllocate</a> signal,
--   you should not use the dimensions of the <tt><i>GtkAllocation</i></tt>
--   passed to the signal handler, as the allocation may contain client
--   side decorations added by GTK+, depending on the windowing system in
--   use.
--   
--   If you are getting a window size in order to position the window on
--   the screen, you should, instead, simply set the window’s semantic type
--   with <a>windowSetTypeHint</a>, which allows the window manager to e.g.
--   center dialogs. Also, if you set the transient parent of dialogs with
--   <a>windowSetTransientFor</a> window managers will often center the
--   dialog over its parent window. It's much preferred to let the window
--   manager handle these cases rather than doing it yourself, because all
--   apps will behave consistently and according to user or system
--   preferences, if the window manager handles it. Also, the window
--   manager can take into account the size of the window decorations and
--   border that it may add, and of which GTK+ has no knowledge.
--   Additionally, positioning windows in global screen coordinates may not
--   be allowed by the windowing system. For more information, see:
--   <a>windowSetPosition</a>.
windowGetSize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Int32, Int32)

-- | Gets the value set by <a>windowSetSkipPagerHint</a>.
--   
--   <i>Since: 2.2</i>
windowGetSkipPagerHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Gets the value set by <a>windowSetSkipTaskbarHint</a>
--   
--   <i>Since: 2.2</i>
windowGetSkipTaskbarHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Retrieves the title of the window. See <a>windowSetTitle</a>.
windowGetTitle :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Text)

-- | Returns the custom titlebar that has been set with
--   <a>windowSetTitlebar</a>.
--   
--   <i>Since: 3.16</i>
windowGetTitlebar :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Widget)

-- | Fetches the transient parent for this window. See
--   <a>windowSetTransientFor</a>.
windowGetTransientFor :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Window)

-- | Gets the value set by <a>windowSetUrgencyHint</a>
--   
--   <i>Since: 2.8</i>
windowGetUrgencyHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns whether <i><tt>window</tt></i> has an explicit window group.
windowHasGroup :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns whether the input focus is within this GtkWindow. For real
--   toplevel windows, this is identical to <a>windowIsActive</a>, but for
--   embedded windows, like <a>Plug</a>, the results will differ.
--   
--   <i>Since: 2.4</i>
windowHasToplevelFocus :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns whether the window is part of the current active toplevel.
--   (That is, the toplevel window receiving keystrokes.) The return value
--   is <a>True</a> if the window is active toplevel itself, but also if it
--   is, say, a <a>Plug</a> embedded in the active toplevel. You might use
--   this function if you wanted to draw a widget differently in an active
--   window from a widget in an inactive window. See
--   <a>windowHasToplevelFocus</a>
--   
--   <i>Since: 2.4</i>
windowIsActive :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Retrieves the current maximized state of <i><tt>window</tt></i>.
--   
--   Note that since maximization is ultimately handled by the window
--   manager and happens asynchronously to an application request, you
--   shouldn’t assume the return value of this function changing
--   immediately (or at all), as an effect of calling <a>windowMaximize</a>
--   or <a>windowUnmaximize</a>.
--   
--   <i>Since: 3.12</i>
windowIsMaximized :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Activates the targets associated with the mnemonic.
windowMnemonicActivate :: (HasCallStack, MonadIO m, IsWindow a) => a -> Word32 -> [ModifierType] -> m Bool

-- | Parses a standard X Window System geometry string - see the manual
--   page for X (type “man X”) for details on this.
--   <a>windowParseGeometry</a> does work on all GTK+ ports including Win32
--   but is primarily intended for an X environment.
--   
--   If either a size or a position can be extracted from the geometry
--   string, <a>windowParseGeometry</a> returns <a>True</a> and calls
--   <a>windowSetDefaultSize</a> and/or <a>windowMove</a> to resize/move
--   the window.
--   
--   If <a>windowParseGeometry</a> returns <a>True</a>, it will also set
--   the <tt><i>GDK_HINT_USER_POS</i></tt> and/or
--   <tt><i>GDK_HINT_USER_SIZE</i></tt> hints indicating to the window
--   manager that the size/position of the window was user-specified. This
--   causes most window managers to honor the geometry.
--   
--   Note that for <a>windowParseGeometry</a> to work as expected, it has
--   to be called when the window has its “final” size, i.e. after calling
--   <a>widgetShowAll</a> on the contents and <a>windowSetGeometryHints</a>
--   on the window.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   #include &lt;gtk/gtk.h&gt;
--   
--   static void
--   fill_with_content (GtkWidget *vbox)
--   {
--     // fill with content...
--   }
--   
--   int
--   main (int argc, char *argv[])
--   {
--     GtkWidget *window, *vbox;
--     GdkGeometry size_hints = {
--       100, 50, 0, 0, 100, 50, 10,
--       10, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST
--     };
--   
--     gtk_init (&amp;argc, &amp;argv);
--   
--     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
--     vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
--   
--     gtk_container_add (GTK_CONTAINER (window), vbox);
--     fill_with_content (vbox);
--     gtk_widget_show_all (vbox);
--   
--     gtk_window_set_geometry_hints (GTK_WINDOW (window),
--   	  			    NULL,
--   				    &amp;size_hints,
--   				    GDK_HINT_MIN_SIZE |
--   				    GDK_HINT_BASE_SIZE |
--   				    GDK_HINT_RESIZE_INC);
--   
--     if (argc &gt; 1)
--       {
--         gboolean res;
--         res = gtk_window_parse_geometry (GTK_WINDOW (window),
--                                          argv[1]);
--         if (! res)
--           fprintf (stderr,
--                    "Failed to parse “%s”\n",
--                    argv[1]);
--       }
--   
--     gtk_widget_show_all (window);
--     gtk_main ();
--   
--     return 0;
--   }
--   </pre>
windowParseGeometry :: (HasCallStack, MonadIO m, IsWindow a) => a -> Text -> m Bool

-- | Presents a window to the user. This function should not be used as
--   when it is called, it is too late to gather a valid timestamp to allow
--   focus stealing prevention to work correctly.
windowPresent :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Presents a window to the user. This may mean raising the window in the
--   stacking order, deiconifying it, moving it to the current desktop,
--   and/or giving it the keyboard focus, possibly dependent on the user’s
--   platform, window manager, and preferences.
--   
--   If <i><tt>window</tt></i> is hidden, this function calls
--   <a>widgetShow</a> as well.
--   
--   This function should be used when the user tries to open a window
--   that’s already open. Say for example the preferences dialog is
--   currently open, and the user chooses Preferences from the menu a
--   second time; use <a>windowPresent</a> to move the already-open dialog
--   where the user can see it.
--   
--   Presents a window to the user in response to a user interaction. The
--   timestamp should be gathered when the window was requested to be shown
--   (when clicking a link for example), rather than once the window is
--   ready to be shown.
--   
--   <i>Since: 2.8</i>
windowPresentWithTime :: (HasCallStack, MonadIO m, IsWindow a) => a -> Word32 -> m ()

-- | Propagate a key press or release event to the focus widget and up the
--   focus container chain until a widget handles <i><tt>event</tt></i>.
--   This is normally called by the default <a>key_press_event</a> and
--   <a>key_release_event</a> handlers for toplevel windows, however in
--   some cases it may be useful to call this directly when overriding the
--   standard key handling for a toplevel window.
--   
--   <i>Since: 2.4</i>
windowPropagateKeyEvent :: (HasCallStack, MonadIO m, IsWindow a) => a -> EventKey -> m Bool

-- | Reverses the effects of <a>windowAddAccelGroup</a>.
windowRemoveAccelGroup :: (HasCallStack, MonadIO m, IsWindow a, IsAccelGroup b) => a -> b -> m ()

-- | Removes a mnemonic from this window.
windowRemoveMnemonic :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Word32 -> b -> m ()

-- | Hides <i><tt>window</tt></i>, then reshows it, resetting the default
--   size and position of the window. Used by GUI builders only.
windowReshowWithInitialSize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Determines whether a resize grip is visible for the specified window.
--   
--   <i>Since: 3.0</i>
windowResizeGripIsVisible :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Like <a>windowResize</a>, but <i><tt>width</tt></i> and
--   <i><tt>height</tt></i> are interpreted in terms of the base size and
--   increment set with gtk_window_set_geometry_hints.
--   
--   <i>Since: 3.0</i>
windowResizeToGeometry :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> m ()

-- | Sets or unsets the <a>Application</a> associated with the window.
--   
--   The application will be kept alive for at least as long as it has any
--   windows associated with it (see <a>applicationHold</a> for a way to
--   keep it alive without windows).
--   
--   Normally, the connection between the application and the window will
--   remain until the window is destroyed, but you can explicitly remove it
--   by setting the <i><tt>application</tt></i> to <a>Nothing</a>.
--   
--   This is equivalent to calling <a>applicationRemoveWindow</a> and/or
--   <a>applicationAddWindow</a> on the old/new applications as relevant.
--   
--   <i>Since: 3.0</i>
windowSetApplication :: (HasCallStack, MonadIO m, IsWindow a, IsApplication b) => a -> Maybe b -> m ()

-- | Marks <i><tt>window</tt></i> as attached to
--   <i><tt>attachWidget</tt></i>. This creates a logical binding between
--   the window and the widget it belongs to, which is used by GTK+ to
--   propagate information such as styling or accessibility to
--   <i><tt>window</tt></i> as if it was a children of
--   <i><tt>attachWidget</tt></i>.
--   
--   Examples of places where specifying this relation is useful are for
--   instance a <a>Menu</a> created by a <a>ComboBox</a>, a completion
--   popup window created by <a>Entry</a> or a typeahead search entry
--   created by <a>TreeView</a>.
--   
--   Note that this function should not be confused with
--   <a>windowSetTransientFor</a>, which specifies a window manager
--   relation between two toplevels instead.
--   
--   Passing <a>Nothing</a> for <i><tt>attachWidget</tt></i> detaches the
--   window.
--   
--   <i>Since: 3.4</i>
windowSetAttachedTo :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> m ()

-- | Like <a>windowSetDefaultSize</a>, but <i><tt>width</tt></i> and
--   <i><tt>height</tt></i> are interpreted in terms of the base size and
--   increment set with gtk_window_set_geometry_hints.
--   
--   <i>Since: 3.0</i>
windowSetDefaultGeometry :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> m ()

-- | By default, windows have a close button in the window frame. Some
--   [window managers][gtk-X11-arch] allow GTK+ to disable this button. If
--   you set the deletable property to <a>False</a> using this function,
--   GTK+ will do its best to convince the window manager not to show a
--   close button. Depending on the system, this function may not have any
--   effect when called on a window that is already visible, so you should
--   call it before calling <a>widgetShow</a>.
--   
--   On Windows, this function always works, since there’s no window
--   manager policy involved.
--   
--   <i>Since: 2.10</i>
windowSetDeletable :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | If <i><tt>focus</tt></i> is not the current focus widget, and is
--   focusable, sets it as the focus widget for the window. If
--   <i><tt>focus</tt></i> is <a>Nothing</a>, unsets the focus widget for
--   this window. To set the focus to a particular widget in the toplevel,
--   it is usually more convenient to use <a>widgetGrabFocus</a> instead of
--   this function.
windowSetFocus :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the <a>Window:focusVisible</a> property.
--   
--   <i>Since: 3.2</i>
windowSetFocusVisible :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Window gravity defines the meaning of coordinates passed to
--   <a>windowMove</a>. See <a>windowMove</a> and <a>Gravity</a> for more
--   details.
--   
--   The default window gravity is <tt><i>GDK_GRAVITY_NORTH_WEST</i></tt>
--   which will typically “do what you mean.”
windowSetGravity :: (HasCallStack, MonadIO m, IsWindow a) => a -> Gravity -> m ()

-- | Sets whether <i><tt>window</tt></i> has a corner resize grip.
--   
--   Note that the resize grip is only shown if the window is actually
--   resizable and not maximized. Use <a>windowResizeGripIsVisible</a> to
--   find out if the resize grip is currently shown.
--   
--   <i>Since: 3.0</i>
windowSetHasResizeGrip :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Tells GTK+ whether to drop its extra reference to the window when
--   <a>widgetDestroy</a> is called.
--   
--   This function is only exported for the benefit of language bindings
--   which may need to keep the window alive until their wrapper object is
--   garbage collected. There is no justification for ever calling this
--   function in an application.
--   
--   <i>Since: 3.0</i>
windowSetHasUserRefCount :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | If <i><tt>setting</tt></i> is <a>True</a>, then <i><tt>window</tt></i>
--   will request that it’s titlebar should be hidden when maximized. This
--   is useful for windows that don’t convey any information other than the
--   application name in the titlebar, to put the available screen space to
--   better use. If the underlying window system does not support the
--   request, the setting will not have any effect.
--   
--   Note that custom titlebars set with <a>windowSetTitlebar</a> are not
--   affected by this. The application is in full control of their content
--   and visibility anyway.
--   
--   <i>Since: 3.4</i>
windowSetHideTitlebarWhenMaximized :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Sets up the icon representing a <a>Window</a>. This icon is used when
--   the window is minimized (also known as iconified). Some window
--   managers or desktop environments may also place it in the window
--   frame, or display it in other contexts. On others, the icon is not
--   used at all, so your mileage may vary.
--   
--   The icon should be provided in whatever size it was naturally drawn;
--   that is, don’t scale the image before passing it to GTK+. Scaling is
--   postponed until the last minute, when the desired final size is known,
--   to allow best quality.
--   
--   If you have your icon hand-drawn in multiple sizes, use
--   <a>windowSetIconList</a>. Then the best size will be used.
--   
--   This function is equivalent to calling <a>windowSetIconList</a> with a
--   1-element list.
--   
--   See also <a>windowSetDefaultIconList</a> to set the icon for all
--   windows in your application in one go.
windowSetIcon :: (HasCallStack, MonadIO m, IsWindow a, IsPixbuf b) => a -> Maybe b -> m ()

-- | Sets the icon for <i><tt>window</tt></i>. Warns on failure if
--   <i><tt>err</tt></i> is <a>Nothing</a>.
--   
--   This function is equivalent to calling <a>windowSetIcon</a> with a
--   pixbuf created by loading the image from <i><tt>filename</tt></i>.
--   
--   <i>Since: 2.2</i>
windowSetIconFromFile :: (HasCallStack, MonadIO m, IsWindow a) => a -> [Char] -> m ()

-- | Sets the mnemonic modifier for this window.
windowSetMnemonicModifier :: (HasCallStack, MonadIO m, IsWindow a) => a -> [ModifierType] -> m ()

-- | Sets the <a>Window:mnemonicsVisible</a> property.
--   
--   <i>Since: 2.20</i>
windowSetMnemonicsVisible :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Sets a position constraint for this window. If the old or new
--   constraint is <a>WindowPositionCenterAlways</a>, this will also cause
--   the window to be repositioned to satisfy the new constraint.
windowSetPosition :: (HasCallStack, MonadIO m, IsWindow a) => a -> WindowPosition -> m ()

-- | Sets whether the user can resize a window. Windows are user resizable
--   by default.
windowSetResizable :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Sets the <a>Screen</a> where the <i><tt>window</tt></i> is displayed;
--   if the window is already mapped, it will be unmapped, and then
--   remapped on the new screen.
--   
--   <i>Since: 2.2</i>
windowSetScreen :: (HasCallStack, MonadIO m, IsWindow a, IsScreen b) => a -> b -> m ()

-- | Sets a custom titlebar for <i><tt>window</tt></i>.
--   
--   A typical widget used here is <a>HeaderBar</a>, as it provides various
--   features expected of a titlebar while allowing the addition of child
--   widgets to it.
--   
--   If you set a custom titlebar, GTK+ will do its best to convince the
--   window manager not to put its own titlebar on the window. Depending on
--   the system, this function may not work for a window that is already
--   visible, so you set the titlebar before calling <a>widgetShow</a>.
--   
--   <i>Since: 3.10</i>
windowSetTitlebar :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> m ()

-- | Don’t use this function. It sets the X Window System “class” and
--   “name” hints for a window. According to the ICCCM, you should always
--   set these to the same value for all windows in an application, and
--   GTK+ sets them to that value by default, so calling this function is
--   sort of pointless. However, you may want to call <a>windowSetRole</a>
--   on each window in your application, for the benefit of the session
--   manager. Setting the role allows the window manager to restore window
--   positions when loading a saved session.
windowSetWmclass :: (HasCallStack, MonadIO m, IsWindow a) => a -> Text -> Text -> m ()

-- | Gets the value set by <a>windowSetDefaultIconList</a>. The list is a
--   copy and should be freed with <tt><i>g_list_free()</i></tt>, but the
--   pixbufs in the list have not had their reference count incremented.
windowGetDefaultIconList :: (HasCallStack, MonadIO m) => m [Pixbuf]

-- | Returns the fallback icon name for windows that has been set with
--   <a>windowSetDefaultIconName</a>. The returned string is owned by GTK+
--   and should not be modified. It is only valid until the next call to
--   <a>windowSetDefaultIconName</a>.
--   
--   <i>Since: 2.16</i>
windowGetDefaultIconName :: (HasCallStack, MonadIO m) => m Text

-- | Returns a list of all existing toplevel windows. The widgets in the
--   list are not individually referenced. If you want to iterate through
--   the list and perform actions involving callbacks that might destroy
--   the widgets, you must call <tt>g_list_foreach (result,
--   (GFunc)g_object_ref, NULL)</tt> first, and then unref all the widgets
--   afterwards.
windowListToplevels :: (HasCallStack, MonadIO m) => m [Widget]

-- | By default, after showing the first <a>Window</a>, GTK+ calls
--   <a>notifyStartupComplete</a>. Call this function to disable the
--   automatic startup notification. You might do this if your first window
--   is a splash screen, and you want to delay notification until after
--   your real main window has been shown, for example.
--   
--   In that example, you would disable startup notification temporarily,
--   show your splash screen, then re-enable it so that showing the main
--   window would automatically result in notification.
--   
--   <i>Since: 2.2</i>
windowSetAutoStartupNotification :: (HasCallStack, MonadIO m) => Bool -> m ()

-- | Sets an icon to be used as fallback for windows that haven't had
--   <a>windowSetIconList</a> called on them from a file on disk. Warns on
--   failure if <i><tt>err</tt></i> is <a>Nothing</a>.
--   
--   <i>Since: 2.2</i>
windowSetDefaultIconFromFile :: (HasCallStack, MonadIO m) => [Char] -> m ()

-- | Sets an icon list to be used as fallback for windows that haven't had
--   <a>windowSetIconList</a> called on them to set up a window-specific
--   icon list. This function allows you to set up the icon for all windows
--   in your app at once.
--   
--   See <a>windowSetIconList</a> for more details.
windowSetDefaultIconList :: (HasCallStack, MonadIO m, IsPixbuf a) => [a] -> m ()

-- | Sets an icon to be used as fallback for windows that haven't had
--   <a>windowSetIconList</a> called on them from a named themed icon, see
--   <a>windowSetIconName</a>.
--   
--   <i>Since: 2.6</i>
windowSetDefaultIconName :: (HasCallStack, MonadIO m) => Text -> m ()

-- | Opens or closes the [interactive debugger][interactive-debugging],
--   which offers access to the widget hierarchy of the application and to
--   useful debugging tools.
--   
--   <i>Since: 3.14</i>
windowSetInteractiveDebugging :: (HasCallStack, MonadIO m) => Bool -> m ()

-- | Connect a signal handler for the <a>accelClosuresChanged</a> signal,
--   to be run before the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #accelClosuresChanged callback
--   </pre>
onWidgetAccelClosuresChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetAccelClosuresChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>accelClosuresChanged</a> signal,
--   to be run after the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #accelClosuresChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetAccelClosuresChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetAccelClosuresChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>buttonPressEvent</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #buttonPressEvent callback
--   </pre>
onWidgetButtonPressEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetButtonPressEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>buttonPressEvent</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #buttonPressEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetButtonPressEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetButtonPressEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>buttonReleaseEvent</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #buttonReleaseEvent callback
--   </pre>
onWidgetButtonReleaseEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetButtonReleaseEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>buttonReleaseEvent</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #buttonReleaseEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetButtonReleaseEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetButtonReleaseEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>canActivateAccel</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #canActivateAccel callback
--   </pre>
onWidgetCanActivateAccel :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetCanActivateAccelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>canActivateAccel</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #canActivateAccel callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetCanActivateAccel :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetCanActivateAccelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>childNotify</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #childNotify callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to “<tt>child-notify::detail</tt>”
--   instead.
onWidgetChildNotify :: (IsWidget a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => WidgetChildNotifyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>childNotify</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #childNotify callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to “<tt>child-notify::detail</tt>”
--   instead.
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetChildNotify :: (IsWidget a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => WidgetChildNotifyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>compositedChanged</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #compositedChanged callback
--   </pre>
onWidgetCompositedChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetCompositedChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>compositedChanged</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #compositedChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetCompositedChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetCompositedChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>configureEvent</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #configureEvent callback
--   </pre>
onWidgetConfigureEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetConfigureEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>configureEvent</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #configureEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetConfigureEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetConfigureEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>damageEvent</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #damageEvent callback
--   </pre>
onWidgetDamageEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDamageEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>damageEvent</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #damageEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDamageEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDamageEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteEvent</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #deleteEvent callback
--   </pre>
onWidgetDeleteEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDeleteEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteEvent</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #deleteEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDeleteEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDeleteEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>destroy</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #destroy callback
--   </pre>
onWidgetDestroy :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDestroyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>destroy</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #destroy callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDestroy :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDestroyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>destroyEvent</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #destroyEvent callback
--   </pre>
onWidgetDestroyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDestroyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>destroyEvent</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #destroyEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDestroyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDestroyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>directionChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #directionChanged callback
--   </pre>
onWidgetDirectionChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDirectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>directionChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #directionChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDirectionChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDirectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragBegin</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #dragBegin callback
--   </pre>
onWidgetDragBegin :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragBegin</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #dragBegin callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDragBegin :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragDataDelete</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #dragDataDelete callback
--   </pre>
onWidgetDragDataDelete :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragDataDeleteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragDataDelete</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #dragDataDelete callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDragDataDelete :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragDataDeleteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragDataGet</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #dragDataGet callback
--   </pre>
onWidgetDragDataGet :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragDataGetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragDataGet</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #dragDataGet callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDragDataGet :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragDataGetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragDataReceived</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #dragDataReceived callback
--   </pre>
onWidgetDragDataReceived :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragDataReceivedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragDataReceived</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #dragDataReceived callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDragDataReceived :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragDataReceivedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragDrop</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #dragDrop callback
--   </pre>
onWidgetDragDrop :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragDropCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragDrop</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #dragDrop callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDragDrop :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragDropCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragEnd</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #dragEnd callback
--   </pre>
onWidgetDragEnd :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragEnd</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #dragEnd callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDragEnd :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragFailed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #dragFailed callback
--   </pre>
onWidgetDragFailed :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragFailedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragFailed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #dragFailed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDragFailed :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragFailedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragLeave</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #dragLeave callback
--   </pre>
onWidgetDragLeave :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragLeave</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #dragLeave callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDragLeave :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragMotion</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #dragMotion callback
--   </pre>
onWidgetDragMotion :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragMotionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragMotion</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #dragMotion callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDragMotion :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDragMotionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>draw</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> widget #draw callback
--   </pre>
onWidgetDraw :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDrawCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>draw</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #draw callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDraw :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDrawCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>enterNotifyEvent</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #enterNotifyEvent callback
--   </pre>
onWidgetEnterNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetEnterNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>enterNotifyEvent</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #enterNotifyEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetEnterNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetEnterNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>event</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> widget #event callback
--   </pre>
onWidgetEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>event</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #event callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>eventAfter</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #eventAfter callback
--   </pre>
onWidgetEventAfter :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetEventAfterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>eventAfter</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #eventAfter callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetEventAfter :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetEventAfterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>focus</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> widget #focus callback
--   </pre>
onWidgetFocus :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>focus</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #focus callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetFocus :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>focusInEvent</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #focusInEvent callback
--   </pre>
onWidgetFocusInEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetFocusInEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>focusInEvent</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #focusInEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetFocusInEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetFocusInEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>focusOutEvent</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #focusOutEvent callback
--   </pre>
onWidgetFocusOutEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetFocusOutEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>focusOutEvent</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #focusOutEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetFocusOutEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetFocusOutEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>grabBrokenEvent</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #grabBrokenEvent callback
--   </pre>
onWidgetGrabBrokenEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetGrabBrokenEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>grabBrokenEvent</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #grabBrokenEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetGrabBrokenEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetGrabBrokenEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>grabFocus</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #grabFocus callback
--   </pre>
onWidgetGrabFocus :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetGrabFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>grabFocus</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #grabFocus callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetGrabFocus :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetGrabFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>grabNotify</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #grabNotify callback
--   </pre>
onWidgetGrabNotify :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetGrabNotifyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>grabNotify</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #grabNotify callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetGrabNotify :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetGrabNotifyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>hide</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> widget #hide callback
--   </pre>
onWidgetHide :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetHideCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>hide</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #hide callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetHide :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetHideCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>hierarchyChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #hierarchyChanged callback
--   </pre>
onWidgetHierarchyChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetHierarchyChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>hierarchyChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #hierarchyChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetHierarchyChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetHierarchyChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>keyPressEvent</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #keyPressEvent callback
--   </pre>
onWidgetKeyPressEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetKeyPressEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>keyPressEvent</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #keyPressEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetKeyPressEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetKeyPressEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>keyReleaseEvent</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #keyReleaseEvent callback
--   </pre>
onWidgetKeyReleaseEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetKeyReleaseEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>keyReleaseEvent</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #keyReleaseEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetKeyReleaseEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetKeyReleaseEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>keynavFailed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #keynavFailed callback
--   </pre>
onWidgetKeynavFailed :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetKeynavFailedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>keynavFailed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #keynavFailed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetKeynavFailed :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetKeynavFailedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>leaveNotifyEvent</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #leaveNotifyEvent callback
--   </pre>
onWidgetLeaveNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetLeaveNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>leaveNotifyEvent</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #leaveNotifyEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetLeaveNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetLeaveNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>map</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> widget #map callback
--   </pre>
onWidgetMap :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMapCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>map</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #map callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetMap :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMapCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>mapEvent</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #mapEvent callback
--   </pre>
onWidgetMapEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMapEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>mapEvent</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #mapEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetMapEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMapEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>mnemonicActivate</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #mnemonicActivate callback
--   </pre>
onWidgetMnemonicActivate :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMnemonicActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>mnemonicActivate</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #mnemonicActivate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetMnemonicActivate :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMnemonicActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>motionNotifyEvent</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #motionNotifyEvent callback
--   </pre>
onWidgetMotionNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMotionNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>motionNotifyEvent</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #motionNotifyEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetMotionNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMotionNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveFocus</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #moveFocus callback
--   </pre>
onWidgetMoveFocus :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMoveFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveFocus</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #moveFocus callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetMoveFocus :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMoveFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>parentSet</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #parentSet callback
--   </pre>
onWidgetParentSet :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetParentSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>parentSet</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #parentSet callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetParentSet :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetParentSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popupMenu</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #popupMenu callback
--   </pre>
onWidgetPopupMenu :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetPopupMenuCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popupMenu</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #popupMenu callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetPopupMenu :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetPopupMenuCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>propertyNotifyEvent</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #propertyNotifyEvent callback
--   </pre>
onWidgetPropertyNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetPropertyNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>propertyNotifyEvent</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #propertyNotifyEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetPropertyNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetPropertyNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>proximityInEvent</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #proximityInEvent callback
--   </pre>
onWidgetProximityInEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetProximityInEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>proximityInEvent</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #proximityInEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetProximityInEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetProximityInEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>proximityOutEvent</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #proximityOutEvent callback
--   </pre>
onWidgetProximityOutEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetProximityOutEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>proximityOutEvent</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #proximityOutEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetProximityOutEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetProximityOutEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>queryTooltip</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #queryTooltip callback
--   </pre>
onWidgetQueryTooltip :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetQueryTooltipCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>queryTooltip</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #queryTooltip callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetQueryTooltip :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetQueryTooltipCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>realize</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #realize callback
--   </pre>
onWidgetRealize :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetRealizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>realize</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #realize callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetRealize :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetRealizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>screenChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #screenChanged callback
--   </pre>
onWidgetScreenChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetScreenChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>screenChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #screenChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetScreenChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetScreenChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scrollEvent</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #scrollEvent callback
--   </pre>
onWidgetScrollEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetScrollEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scrollEvent</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #scrollEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetScrollEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetScrollEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionClearEvent</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #selectionClearEvent callback
--   </pre>
onWidgetSelectionClearEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionClearEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionClearEvent</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #selectionClearEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetSelectionClearEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionClearEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionGet</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #selectionGet callback
--   </pre>
onWidgetSelectionGet :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionGetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionGet</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #selectionGet callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetSelectionGet :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionGetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionNotifyEvent</a> signal,
--   to be run before the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #selectionNotifyEvent callback
--   </pre>
onWidgetSelectionNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionNotifyEvent</a> signal,
--   to be run after the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #selectionNotifyEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetSelectionNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionReceived</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #selectionReceived callback
--   </pre>
onWidgetSelectionReceived :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionReceivedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionReceived</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #selectionReceived callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetSelectionReceived :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionReceivedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionRequestEvent</a> signal,
--   to be run before the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #selectionRequestEvent callback
--   </pre>
onWidgetSelectionRequestEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionRequestEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionRequestEvent</a> signal,
--   to be run after the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #selectionRequestEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetSelectionRequestEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSelectionRequestEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>show</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> widget #show callback
--   </pre>
onWidgetShow :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetShowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>show</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #show callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetShow :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetShowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showHelp</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #showHelp callback
--   </pre>
onWidgetShowHelp :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetShowHelpCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showHelp</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #showHelp callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetShowHelp :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetShowHelpCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>sizeAllocate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #sizeAllocate callback
--   </pre>
onWidgetSizeAllocate :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSizeAllocateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>sizeAllocate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #sizeAllocate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetSizeAllocate :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetSizeAllocateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>stateChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #stateChanged callback
--   </pre>
onWidgetStateChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStateChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>stateChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #stateChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetStateChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStateChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>stateFlagsChanged</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #stateFlagsChanged callback
--   </pre>
onWidgetStateFlagsChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStateFlagsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>stateFlagsChanged</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #stateFlagsChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetStateFlagsChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStateFlagsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>styleSet</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #styleSet callback
--   </pre>
onWidgetStyleSet :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStyleSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>styleSet</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #styleSet callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetStyleSet :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStyleSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>styleUpdated</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #styleUpdated callback
--   </pre>
onWidgetStyleUpdated :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStyleUpdatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>styleUpdated</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #styleUpdated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetStyleUpdated :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStyleUpdatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>touchEvent</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #touchEvent callback
--   </pre>
onWidgetTouchEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetTouchEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>touchEvent</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #touchEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetTouchEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetTouchEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unmap</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> widget #unmap callback
--   </pre>
onWidgetUnmap :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetUnmapCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unmap</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #unmap callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetUnmap :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetUnmapCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unmapEvent</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #unmapEvent callback
--   </pre>
onWidgetUnmapEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetUnmapEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unmapEvent</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #unmapEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetUnmapEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetUnmapEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unrealize</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #unrealize callback
--   </pre>
onWidgetUnrealize :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetUnrealizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unrealize</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #unrealize callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetUnrealize :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetUnrealizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>visibilityNotifyEvent</a> signal,
--   to be run before the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #visibilityNotifyEvent callback
--   </pre>
onWidgetVisibilityNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetVisibilityNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>visibilityNotifyEvent</a> signal,
--   to be run after the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #visibilityNotifyEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetVisibilityNotifyEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetVisibilityNotifyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>windowStateEvent</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #windowStateEvent callback
--   </pre>
onWidgetWindowStateEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetWindowStateEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>windowStateEvent</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #windowStateEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetWindowStateEvent :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetWindowStateEventCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>app-paintable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #appPaintable
--   </pre>
getWidgetAppPaintable :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>app-paintable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #appPaintable <a>:=</a> value ]
--   </pre>
setWidgetAppPaintable :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>app-paintable</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetAppPaintable :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>can-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #canDefault
--   </pre>
getWidgetCanDefault :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>can-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #canDefault <a>:=</a> value ]
--   </pre>
setWidgetCanDefault :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>can-default</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetCanDefault :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>can-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #canFocus
--   </pre>
getWidgetCanFocus :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>can-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #canFocus <a>:=</a> value ]
--   </pre>
setWidgetCanFocus :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>can-focus</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWidgetCanFocus :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>composite-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #compositeChild
--   </pre>
getWidgetCompositeChild :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Get the value of the “<tt>double-buffered</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #doubleBuffered
--   </pre>
getWidgetDoubleBuffered :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>double-buffered</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #doubleBuffered <a>:=</a> value ]
--   </pre>
setWidgetDoubleBuffered :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>double-buffered</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWidgetDoubleBuffered :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>events</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #events
--   </pre>
getWidgetEvents :: (MonadIO m, IsWidget o) => o -> m [EventMask]

-- | Set the value of the “<tt>events</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #events <a>:=</a> value ]
--   </pre>
setWidgetEvents :: (MonadIO m, IsWidget o) => o -> [EventMask] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>events</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetEvents :: (IsWidget o, MonadIO m) => [EventMask] -> m (GValueConstruct o)

-- | Get the value of the “<tt>expand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #expand
--   </pre>
getWidgetExpand :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>expand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #expand <a>:=</a> value ]
--   </pre>
setWidgetExpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>expand</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetExpand :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>focus-on-click</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #focusOnClick
--   </pre>
getWidgetFocusOnClick :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>focus-on-click</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #focusOnClick <a>:=</a> value ]
--   </pre>
setWidgetFocusOnClick :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>focus-on-click</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWidgetFocusOnClick :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>halign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #halign
--   </pre>
getWidgetHalign :: (MonadIO m, IsWidget o) => o -> m Align

-- | Set the value of the “<tt>halign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #halign <a>:=</a> value ]
--   </pre>
setWidgetHalign :: (MonadIO m, IsWidget o) => o -> Align -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>halign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetHalign :: (IsWidget o, MonadIO m) => Align -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #hasDefault
--   </pre>
getWidgetHasDefault :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>has-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #hasDefault <a>:=</a> value ]
--   </pre>
setWidgetHasDefault :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-default</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetHasDefault :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #hasFocus
--   </pre>
getWidgetHasFocus :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>has-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #hasFocus <a>:=</a> value ]
--   </pre>
setWidgetHasFocus :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-focus</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWidgetHasFocus :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-tooltip</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #hasTooltip
--   </pre>
getWidgetHasTooltip :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>has-tooltip</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #hasTooltip <a>:=</a> value ]
--   </pre>
setWidgetHasTooltip :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-tooltip</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetHasTooltip :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>height-request</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #heightRequest
--   </pre>
getWidgetHeightRequest :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “<tt>height-request</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #heightRequest <a>:=</a> value ]
--   </pre>
setWidgetHeightRequest :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>height-request</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWidgetHeightRequest :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>hexpand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #hexpand
--   </pre>
getWidgetHexpand :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>hexpand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #hexpand <a>:=</a> value ]
--   </pre>
setWidgetHexpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hexpand</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetHexpand :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>hexpand-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #hexpandSet
--   </pre>
getWidgetHexpandSet :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>hexpand-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #hexpandSet <a>:=</a> value ]
--   </pre>
setWidgetHexpandSet :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hexpand-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetHexpandSet :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>is-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #isFocus
--   </pre>
getWidgetIsFocus :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>is-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #isFocus <a>:=</a> value ]
--   </pre>
setWidgetIsFocus :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>is-focus</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWidgetIsFocus :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #margin
--   </pre>
getWidgetMargin :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “<tt>margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #margin <a>:=</a> value ]
--   </pre>
setWidgetMargin :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>margin</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetMargin :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>margin-bottom</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #marginBottom
--   </pre>
getWidgetMarginBottom :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “<tt>margin-bottom</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #marginBottom <a>:=</a> value ]
--   </pre>
setWidgetMarginBottom :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>margin-bottom</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetMarginBottom :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>margin-end</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #marginEnd
--   </pre>
getWidgetMarginEnd :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “<tt>margin-end</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #marginEnd <a>:=</a> value ]
--   </pre>
setWidgetMarginEnd :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>margin-end</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWidgetMarginEnd :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>margin-left</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #marginLeft
--   </pre>
getWidgetMarginLeft :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “<tt>margin-left</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #marginLeft <a>:=</a> value ]
--   </pre>
setWidgetMarginLeft :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>margin-left</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetMarginLeft :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>margin-right</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #marginRight
--   </pre>
getWidgetMarginRight :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “<tt>margin-right</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #marginRight <a>:=</a> value ]
--   </pre>
setWidgetMarginRight :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>margin-right</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetMarginRight :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>margin-start</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #marginStart
--   </pre>
getWidgetMarginStart :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “<tt>margin-start</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #marginStart <a>:=</a> value ]
--   </pre>
setWidgetMarginStart :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>margin-start</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetMarginStart :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>margin-top</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #marginTop
--   </pre>
getWidgetMarginTop :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “<tt>margin-top</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #marginTop <a>:=</a> value ]
--   </pre>
setWidgetMarginTop :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>margin-top</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWidgetMarginTop :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #name
--   </pre>
getWidgetName :: (MonadIO m, IsWidget o) => o -> m Text

-- | Set the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #name <a>:=</a> value ]
--   </pre>
setWidgetName :: (MonadIO m, IsWidget o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>name</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetName :: (IsWidget o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>no-show-all</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #noShowAll
--   </pre>
getWidgetNoShowAll :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>no-show-all</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #noShowAll <a>:=</a> value ]
--   </pre>
setWidgetNoShowAll :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>no-show-all</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetNoShowAll :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>opacity</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #opacity
--   </pre>
getWidgetOpacity :: (MonadIO m, IsWidget o) => o -> m Double

-- | Set the value of the “<tt>opacity</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #opacity <a>:=</a> value ]
--   </pre>
setWidgetOpacity :: (MonadIO m, IsWidget o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>opacity</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetOpacity :: (IsWidget o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>parent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #parent
--   </pre>
getWidgetParent :: (MonadIO m, IsWidget o) => o -> m (Maybe Container)

-- | Set the value of the “<tt>parent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #parent <a>:=</a> value ]
--   </pre>
setWidgetParent :: (MonadIO m, IsWidget o, IsContainer a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>parent</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetParent :: (IsWidget o, MonadIO m, IsContainer a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>parent</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #parent
--   </pre>
clearWidgetParent :: (MonadIO m, IsWidget o) => o -> m ()

-- | Get the value of the “<tt>receives-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #receivesDefault
--   </pre>
getWidgetReceivesDefault :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>receives-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #receivesDefault <a>:=</a> value ]
--   </pre>
setWidgetReceivesDefault :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>receives-default</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWidgetReceivesDefault :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>scale-factor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #scaleFactor
--   </pre>
getWidgetScaleFactor :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Get the value of the “<tt>sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #sensitive
--   </pre>
getWidgetSensitive :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #sensitive <a>:=</a> value ]
--   </pre>
setWidgetSensitive :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sensitive</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWidgetSensitive :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #style
--   </pre>
getWidgetStyle :: (MonadIO m, IsWidget o) => o -> m Style

-- | Set the value of the “<tt>style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #style <a>:=</a> value ]
--   </pre>
setWidgetStyle :: (MonadIO m, IsWidget o, IsStyle a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>style</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetStyle :: (IsWidget o, MonadIO m, IsStyle a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>style</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #style
--   </pre>
clearWidgetStyle :: (MonadIO m, IsWidget o) => o -> m ()

-- | Get the value of the “<tt>tooltip-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #tooltipMarkup
--   </pre>
getWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>tooltip-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #tooltipMarkup <a>:=</a> value ]
--   </pre>
setWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip-markup</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWidgetTooltipMarkup :: (IsWidget o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>tooltip-markup</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #tooltipMarkup
--   </pre>
clearWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> m ()

-- | Get the value of the “<tt>tooltip-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #tooltipText
--   </pre>
getWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>tooltip-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #tooltipText <a>:=</a> value ]
--   </pre>
setWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip-text</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetTooltipText :: (IsWidget o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>tooltip-text</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #tooltipText
--   </pre>
clearWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> m ()

-- | Get the value of the “<tt>valign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #valign
--   </pre>
getWidgetValign :: (MonadIO m, IsWidget o) => o -> m Align

-- | Set the value of the “<tt>valign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #valign <a>:=</a> value ]
--   </pre>
setWidgetValign :: (MonadIO m, IsWidget o) => o -> Align -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>valign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetValign :: (IsWidget o, MonadIO m) => Align -> m (GValueConstruct o)

-- | Get the value of the “<tt>vexpand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #vexpand
--   </pre>
getWidgetVexpand :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>vexpand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #vexpand <a>:=</a> value ]
--   </pre>
setWidgetVexpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>vexpand</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetVexpand :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>vexpand-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #vexpandSet
--   </pre>
getWidgetVexpandSet :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>vexpand-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #vexpandSet <a>:=</a> value ]
--   </pre>
setWidgetVexpandSet :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>vexpand-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetVexpandSet :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #visible
--   </pre>
getWidgetVisible :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #visible <a>:=</a> value ]
--   </pre>
setWidgetVisible :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetVisible :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>width-request</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #widthRequest
--   </pre>
getWidgetWidthRequest :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “<tt>width-request</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #widthRequest <a>:=</a> value ]
--   </pre>
setWidgetWidthRequest :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>width-request</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetWidthRequest :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>window</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #window
--   </pre>
getWidgetWindow :: (MonadIO m, IsWidget o) => o -> m (Maybe Window)

-- | For widgets that can be “activated” (buttons, menu items, etc.) this
--   function activates them. Activation is what happens when you press
--   Enter on a widget during key navigation. If <i><tt>widget</tt></i>
--   isn't activatable, the function returns <a>False</a>.
widgetActivate :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Installs an accelerator for this <i><tt>widget</tt></i> in
--   <i><tt>accelGroup</tt></i> that causes <i><tt>accelSignal</tt></i> to
--   be emitted if the accelerator is activated. The
--   <i><tt>accelGroup</tt></i> needs to be added to the widget’s toplevel
--   via <a>windowAddAccelGroup</a>, and the signal must be of type
--   <a>SignalFlagsAction</a>. Accelerators added through this function are
--   not user changeable during runtime. If you want to support
--   accelerators that can be changed by the user, use
--   <a>accelMapAddEntry</a> and <a>widgetSetAccelPath</a> or
--   <a>menuItemSetAccelPath</a> instead.
widgetAddAccelerator :: (HasCallStack, MonadIO m, IsWidget a, IsAccelGroup b) => a -> Text -> b -> Word32 -> [ModifierType] -> [AccelFlags] -> m ()

-- | Adds the device events in the bitfield <i><tt>events</tt></i> to the
--   event mask for <i><tt>widget</tt></i>. See
--   <a>widgetSetDeviceEvents</a> for details.
--   
--   <i>Since: 3.0</i>
widgetAddDeviceEvents :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> [EventMask] -> m ()

-- | Adds a widget to the list of mnemonic labels for this widget. (See
--   <a>widgetListMnemonicLabels</a>). Note the list of mnemonic labels for
--   the widget is cleared when the widget is destroyed, so the caller must
--   make sure to update its internal state at this point as well, by using
--   a connection to the <a>Widget::destroy</a> signal or a weak notifier.
--   
--   <i>Since: 2.4</i>
widgetAddMnemonicLabel :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m ()

-- | Determines whether an accelerator that activates the signal identified
--   by <i><tt>signalId</tt></i> can currently be activated. This is done
--   by emitting the <a>Widget::canActivateAccel</a> signal on
--   <i><tt>widget</tt></i>; if the signal isn’t overridden by a handler or
--   in a derived widget, then the default check is that the widget must be
--   sensitive, and the widget and all its ancestors mapped.
--   
--   <i>Since: 2.4</i>
widgetCanActivateAccel :: (HasCallStack, MonadIO m, IsWidget a) => a -> Word32 -> m Bool

-- | This function is used by custom widget implementations; if you're
--   writing an app, you’d use <a>widgetGrabFocus</a> to move the focus to
--   a particular widget, and <a>containerSetFocusChain</a> to change the
--   focus tab order. So you may want to investigate those functions
--   instead.
--   
--   <a>widgetChildFocus</a> is called by containers as the user moves
--   around the window using keyboard shortcuts. <i><tt>direction</tt></i>
--   indicates what kind of motion is taking place (up, down, left, right,
--   tab forward, tab backward). <a>widgetChildFocus</a> emits the
--   <a>Widget::focus</a> signal; widgets override the default handler for
--   this signal in order to implement appropriate focus behavior.
--   
--   The default <a>focus</a> handler for a widget should return
--   <a>True</a> if moving in <i><tt>direction</tt></i> left the focus on a
--   focusable location inside that widget, and <a>False</a> if moving in
--   <i><tt>direction</tt></i> moved the focus outside the widget. If
--   returning <a>True</a>, widgets normally call <a>widgetGrabFocus</a> to
--   place the focus accordingly; if returning <a>False</a>, they don’t
--   modify the current focus location.
widgetChildFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> DirectionType -> m Bool

-- | Same as <a>widgetPath</a>, but always uses the name of a widget’s
--   type, never uses a custom name set with <a>widgetSetName</a>.
widgetClassPath :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Word32, Text, Text)

-- | Computes whether a container should give this widget extra space when
--   possible. Containers should check this, rather than looking at
--   <a>widgetGetHexpand</a> or <a>widgetGetVexpand</a>.
--   
--   This function already checks whether the widget is visible, so
--   visibility does not need to be checked separately. Non-visible widgets
--   are not expanded.
--   
--   The computed expand value uses either the expand setting explicitly
--   set on the widget itself, or, if none has been explicitly set, the
--   widget may expand if some of its children do.
widgetComputeExpand :: (HasCallStack, MonadIO m, IsWidget a) => a -> Orientation -> m Bool

-- | Creates a new <a>Context</a> with the appropriate font map, font
--   options, font description, and base direction for drawing text for
--   this widget. See also <a>widgetGetPangoContext</a>.
widgetCreatePangoContext :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Context

-- | Creates a new <a>Layout</a> with the appropriate font map, font
--   description, and base direction for drawing text for this widget.
--   
--   If you keep a <a>Layout</a> created in this way around, you need to
--   re-create it when the widget <a>Context</a> is replaced. This can be
--   tracked by using the <a>Widget::screenChanged</a> signal on the
--   widget.
widgetCreatePangoLayout :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Text -> m Layout

-- | This function sets *<i><tt>widgetPointer</tt></i> to <a>Nothing</a> if
--   <i><tt>widgetPointer</tt></i> != <a>Nothing</a>. It’s intended to be
--   used as a callback connected to the “destroy” signal of a widget. You
--   connect <a>widgetDestroyed</a> as a signal handler, and pass the
--   address of your widget variable as user data. Then when the widget is
--   destroyed, the variable will be set to <a>Nothing</a>. Useful for
--   example to avoid multiple copies of the same dialog.
widgetDestroyed :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m Widget

-- | Returns <a>True</a> if <i><tt>device</tt></i> has been shadowed by a
--   GTK+ device grab on another widget, so it would stop sending events to
--   <i><tt>widget</tt></i>. This may be used in the
--   <a>Widget::grabNotify</a> signal to check for specific devices. See
--   <a>deviceGrabAdd</a>.
--   
--   <i>Since: 3.0</i>
widgetDeviceIsShadowed :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> m Bool

-- | This function is equivalent to <a>widgetDragBeginWithCoordinates</a>,
--   passing -1, -1 as coordinates.
widgetDragBegin :: (HasCallStack, MonadIO m, IsWidget a) => a -> TargetList -> [DragAction] -> Int32 -> Maybe Event -> m DragContext

-- | Checks to see if a mouse drag starting at (<i><tt>startX</tt></i>,
--   <i><tt>startY</tt></i>) and ending at (<i><tt>currentX</tt></i>,
--   <i><tt>currentY</tt></i>) has passed the GTK+ drag threshold, and thus
--   should trigger the beginning of a drag-and-drop operation.
widgetDragCheckThreshold :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> Int32 -> Int32 -> Int32 -> m Bool

-- | Add the image targets supported by <a>SelectionData</a> to the target
--   list of the drag destination. The targets are added with
--   <i><tt>info</tt></i> = 0. If you need another value, use
--   <a>targetListAddImageTargets</a> and
--   <a>widgetDragDestSetTargetList</a>.
--   
--   <i>Since: 2.6</i>
widgetDragDestAddImageTargets :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Add the text targets supported by <a>SelectionData</a> to the target
--   list of the drag destination. The targets are added with
--   <i><tt>info</tt></i> = 0. If you need another value, use
--   <a>targetListAddTextTargets</a> and
--   <a>widgetDragDestSetTargetList</a>.
--   
--   <i>Since: 2.6</i>
widgetDragDestAddTextTargets :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Add the URI targets supported by <a>SelectionData</a> to the target
--   list of the drag destination. The targets are added with
--   <i><tt>info</tt></i> = 0. If you need another value, use
--   <a>targetListAddUriTargets</a> and <a>widgetDragDestSetTargetList</a>.
--   
--   <i>Since: 2.6</i>
widgetDragDestAddUriTargets :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Looks for a match between the supported targets of
--   <i><tt>context</tt></i> and the <i><tt>destTargetList</tt></i>,
--   returning the first matching target, otherwise returning
--   <tt><i>GDK_NONE</i></tt>. <i><tt>destTargetList</tt></i> should
--   usually be the return value from <a>widgetDragDestGetTargetList</a>,
--   but some widgets may have different valid targets for different parts
--   of the widget; in that case, they will have to implement a drag_motion
--   handler that passes the correct target list to this function.
widgetDragDestFindTarget :: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b) => a -> b -> Maybe TargetList -> m (Maybe Atom)

-- | Returns the list of targets this widget can accept from drag-and-drop.
widgetDragDestGetTargetList :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe TargetList)

-- | Returns whether the widget has been configured to always emit
--   <a>Widget::dragMotion</a> signals.
--   
--   <i>Since: 2.10</i>
widgetDragDestGetTrackMotion :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Sets this widget as a proxy for drops to another window.
widgetDragDestSetProxy :: (HasCallStack, MonadIO m, IsWidget a, IsWindow b) => a -> b -> DragProtocol -> Bool -> m ()

-- | Sets the target types that this widget can accept from drag-and-drop.
--   The widget must first be made into a drag destination with
--   <a>widgetDragDestSet</a>.
widgetDragDestSetTargetList :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe TargetList -> m ()

-- | Tells the widget to emit <a>Widget::dragMotion</a> and
--   <a>Widget::dragLeave</a> events regardless of the targets and the
--   <a>DestDefaultsMotion</a> flag.
--   
--   This may be used when a widget wants to do generic actions regardless
--   of the targets that the source offers.
--   
--   <i>Since: 2.10</i>
widgetDragDestSetTrackMotion :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Clears information about a drop destination set with
--   <a>widgetDragDestSet</a>. The widget will no longer receive
--   notification of drags.
widgetDragDestUnset :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Add the writable image targets supported by <a>SelectionData</a> to
--   the target list of the drag source. The targets are added with
--   <i><tt>info</tt></i> = 0. If you need another value, use
--   <a>targetListAddImageTargets</a> and
--   <a>widgetDragSourceSetTargetList</a>.
--   
--   <i>Since: 2.6</i>
widgetDragSourceAddImageTargets :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Add the text targets supported by <a>SelectionData</a> to the target
--   list of the drag source. The targets are added with
--   <i><tt>info</tt></i> = 0. If you need another value, use
--   <a>targetListAddTextTargets</a> and
--   <a>widgetDragSourceSetTargetList</a>.
--   
--   <i>Since: 2.6</i>
widgetDragSourceAddTextTargets :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Add the URI targets supported by <a>SelectionData</a> to the target
--   list of the drag source. The targets are added with
--   <i><tt>info</tt></i> = 0. If you need another value, use
--   <a>targetListAddUriTargets</a> and
--   <a>widgetDragSourceSetTargetList</a>.
--   
--   <i>Since: 2.6</i>
widgetDragSourceAddUriTargets :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Gets the list of targets this widget can provide for drag-and-drop.
--   
--   <i>Since: 2.4</i>
widgetDragSourceGetTargetList :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe TargetList)

-- | Sets the icon that will be used for drags from a particular source to
--   <i><tt>icon</tt></i>. See the docs for <a>IconTheme</a> for more
--   details.
--   
--   <i>Since: 3.2</i>
widgetDragSourceSetIconGicon :: (HasCallStack, MonadIO m, IsWidget a, IsIcon b) => a -> b -> m ()

-- | Sets the icon that will be used for drags from a particular source to
--   a themed icon. See the docs for <a>IconTheme</a> for more details.
--   
--   <i>Since: 2.8</i>
widgetDragSourceSetIconName :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> m ()

-- | Sets the icon that will be used for drags from a particular widget
--   from a <a>Pixbuf</a>. GTK+ retains a reference for
--   <i><tt>pixbuf</tt></i> and will release it when it is no longer
--   needed.
widgetDragSourceSetIconPixbuf :: (HasCallStack, MonadIO m, IsWidget a, IsPixbuf b) => a -> b -> m ()

-- | Sets the icon that will be used for drags from a particular source to
--   a stock icon.
widgetDragSourceSetIconStock :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> m ()

-- | Changes the target types that this widget offers for drag-and-drop.
--   The widget must first be made into a drag source with
--   <a>widgetDragSourceSet</a>.
--   
--   <i>Since: 2.4</i>
widgetDragSourceSetTargetList :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe TargetList -> m ()

-- | Undoes the effects of <a>widgetDragSourceSet</a>.
widgetDragSourceUnset :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Removes a highlight set by <a>widgetDragHighlight</a> from a widget.
widgetDragUnhighlight :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Ensures that <i><tt>widget</tt></i> has a style
--   (<i><tt>widget</tt></i>-&gt;style).
--   
--   Not a very useful function; most of the time, if you want the style,
--   the widget is realized, and realized widgets are guaranteed to have a
--   style already.
widgetEnsureStyle :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Notifies the user about an input-related error on this widget. If the
--   <a>Settings:gtkErrorBell</a> setting is <a>True</a>, it calls
--   <a>windowBeep</a>, otherwise it does nothing.
--   
--   Note that the effect of <a>windowBeep</a> can be configured in many
--   ways, depending on the windowing backend and the desktop environment
--   or window manager that is used.
--   
--   <i>Since: 2.12</i>
widgetErrorBell :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Stops emission of <a>Widget::childNotify</a> signals on
--   <i><tt>widget</tt></i>. The signals are queued until
--   <a>widgetThawChildNotify</a> is called on <i><tt>widget</tt></i>.
--   
--   This is the analogue of <a>objectFreezeNotify</a> for child
--   properties.
widgetFreezeChildNotify :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Returns the accessible object that describes the widget to an
--   assistive technology.
--   
--   If accessibility support is not available, this <a>Object</a> instance
--   may be a no-op. Likewise, if no class-specific <a>Object</a>
--   implementation is available for the widget instance in question, it
--   will inherit an <a>Object</a> implementation from the first ancestor
--   class for which such an implementation is defined.
--   
--   The documentation of the <a>ATK</a> library contains more information
--   about accessible objects and their uses.
widgetGetAccessible :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Object

-- | Retrieves the <a>ActionGroup</a> that was registered using
--   <i><tt>prefix</tt></i>. The resulting <a>ActionGroup</a> may have been
--   registered to <i><tt>widget</tt></i> or any <a>Widget</a> in its
--   ancestry.
--   
--   If no action group was found matching <i><tt>prefix</tt></i>, then
--   <a>Nothing</a> is returned.
--   
--   <i>Since: 3.16</i>
widgetGetActionGroup :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> m (Maybe ActionGroup)

-- | Returns the baseline that has currently been allocated to
--   <i><tt>widget</tt></i>. This function is intended to be used when
--   implementing handlers for the <a>Widget::draw</a> function, and when
--   allocating child widgets in
--   <a>Widget</a>::<tt><i>size_allocate</i></tt>.
--   
--   <i>Since: 3.10</i>
widgetGetAllocatedBaseline :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Returns the height that has currently been allocated to
--   <i><tt>widget</tt></i>. This function is intended to be used when
--   implementing handlers for the <a>Widget::draw</a> function.
widgetGetAllocatedHeight :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Retrieves the widget’s allocated size.
--   
--   This function returns the last values passed to
--   <a>widgetSizeAllocateWithBaseline</a>. The value differs from the size
--   returned in <a>widgetGetAllocation</a> in that functions like
--   <a>widgetSetHalign</a> can adjust the allocation, but not the value
--   returned by this function.
--   
--   If a widget is not visible, its allocated size is 0.
--   
--   <i>Since: 3.20</i>
widgetGetAllocatedSize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Rectangle, Int32)

-- | Returns the width that has currently been allocated to
--   <i><tt>widget</tt></i>. This function is intended to be used when
--   implementing handlers for the <a>Widget::draw</a> function.
widgetGetAllocatedWidth :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Retrieves the widget’s allocation.
--   
--   Note, when implementing a <a>Container</a>: a widget’s allocation will
--   be its “adjusted” allocation, that is, the widget’s parent container
--   typically calls <a>widgetSizeAllocate</a> with an allocation, and that
--   allocation is then adjusted (to handle margin and alignment for
--   example) before assignment to the widget. <a>widgetGetAllocation</a>
--   returns the adjusted allocation that was actually assigned to the
--   widget. The adjusted allocation is guaranteed to be completely
--   contained within the <a>widgetSizeAllocate</a> allocation, however. So
--   a <a>Container</a> is guaranteed that its children stay inside the
--   assigned bounds, but not that they have exactly the bounds the
--   container assigned. There is no way to get the original allocation
--   assigned by <a>widgetSizeAllocate</a>, since it isn’t stored; if a
--   container implementation needs that information it will have to track
--   it itself.
--   
--   <i>Since: 2.18</i>
widgetGetAllocation :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Rectangle

-- | Gets the first ancestor of <i><tt>widget</tt></i> with type
--   <i><tt>widgetType</tt></i>. For example, <tt>gtk_widget_get_ancestor
--   (widget, GTK_TYPE_BOX)</tt> gets the first <a>Box</a> that’s an
--   ancestor of <i><tt>widget</tt></i>. No reference will be added to the
--   returned widget; it should not be unreferenced. See note about
--   checking for a toplevel <a>Window</a> in the docs for
--   <a>widgetGetToplevel</a>.
--   
--   Note that unlike <a>widgetIsAncestor</a>, <a>widgetGetAncestor</a>
--   considers <i><tt>widget</tt></i> to be an ancestor of itself.
widgetGetAncestor :: (HasCallStack, MonadIO m, IsWidget a) => a -> GType -> m (Maybe Widget)

-- | Determines whether the application intends to draw on the widget in an
--   <a>Widget::draw</a> handler.
--   
--   See <a>widgetSetAppPaintable</a>
--   
--   <i>Since: 2.18</i>
widgetGetAppPaintable :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines whether <i><tt>widget</tt></i> can be a default widget. See
--   <a>widgetSetCanDefault</a>.
--   
--   <i>Since: 2.18</i>
widgetGetCanDefault :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines whether <i><tt>widget</tt></i> can own the input focus. See
--   <a>widgetSetCanFocus</a>.
--   
--   <i>Since: 2.18</i>
widgetGetCanFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | This function is only for use in widget implementations. Obtains
--   <i><tt>widget</tt></i>-&gt;requisition, unless someone has forced a
--   particular geometry on the widget (e.g. with
--   <a>widgetSetSizeRequest</a>), in which case it returns that geometry
--   instead of the widget's requisition.
--   
--   This function differs from <a>widgetSizeRequest</a> in that it
--   retrieves the last size request value from
--   <i><tt>widget</tt></i>-&gt;requisition, while <a>widgetSizeRequest</a>
--   actually calls the "size_request" method on <i><tt>widget</tt></i> to
--   compute the size request and fill in
--   <i><tt>widget</tt></i>-&gt;requisition, and only then returns
--   <i><tt>widget</tt></i>-&gt;requisition.
--   
--   Because this function does not call the “size_request” method, it can
--   only be used when you know that <i><tt>widget</tt></i>-&gt;requisition
--   is up-to-date, that is, <a>widgetSizeRequest</a> has been called since
--   the last time a resize was queued. In general, only container
--   implementations have this information; applications should use
--   <a>widgetSizeRequest</a>.
widgetGetChildRequisition :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Requisition

-- | Gets the value set with <a>widgetSetChildVisible</a>. If you feel a
--   need to use this function, your code probably needs reorganization.
--   
--   This function is only useful for container implementations and never
--   should be called by an application.
widgetGetChildVisible :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Retrieves the widget’s clip area.
--   
--   The clip area is the area in which all of <i><tt>widget</tt></i>'s
--   drawing will happen. Other toolkits call it the bounding box.
--   
--   Historically, in GTK+ the clip area has been equal to the allocation
--   retrieved via <a>widgetGetAllocation</a>.
--   
--   <i>Since: 3.14</i>
widgetGetClip :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Rectangle

-- | Returns the clipboard object for the given selection to be used with
--   <i><tt>widget</tt></i>. <i><tt>widget</tt></i> must have a
--   <a>Display</a> associated with it, so must be attached to a toplevel
--   window.
--   
--   <i>Since: 2.2</i>
widgetGetClipboard :: (HasCallStack, MonadIO m, IsWidget a) => a -> Atom -> m Clipboard

-- | Obtains the composite name of a widget.
widgetGetCompositeName :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Text

-- | Returns whether <i><tt>device</tt></i> can interact with
--   <i><tt>widget</tt></i> and its children. See
--   <a>widgetSetDeviceEnabled</a>.
--   
--   <i>Since: 3.0</i>
widgetGetDeviceEnabled :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> m Bool

-- | Returns the events mask for the widget corresponding to an specific
--   device. These are the events that the widget will receive when
--   <i><tt>device</tt></i> operates on it.
--   
--   <i>Since: 3.0</i>
widgetGetDeviceEvents :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> m [EventMask]

-- | Get the <a>Display</a> for the toplevel window associated with this
--   widget. This function can only be called after the widget has been
--   added to a widget hierarchy with a <a>Window</a> at the top.
--   
--   In general, you should only create display specific resources when a
--   widget has been realized, and you should free those resources when the
--   widget is unrealized.
--   
--   <i>Since: 2.2</i>
widgetGetDisplay :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Display

-- | Determines whether the widget is double buffered.
--   
--   See <a>widgetSetDoubleBuffered</a>
--   
--   <i>Since: 2.18</i>
widgetGetDoubleBuffered :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Returns the event mask (see <a>EventMask</a>) for the widget. These
--   are the events that the widget will receive.
--   
--   Note: Internally, the widget event mask will be the logical OR of the
--   event mask set through <a>widgetSetEvents</a> or
--   <a>widgetAddEvents</a>, and the event mask necessary to cater for
--   every <a>EventController</a> created for the widget.
widgetGetEvents :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Returns whether the widget should grab focus when it is clicked with
--   the mouse. See <a>widgetSetFocusOnClick</a>.
--   
--   <i>Since: 3.20</i>
widgetGetFocusOnClick :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets the font map that has been set with <a>widgetSetFontMap</a>.
--   
--   <i>Since: 3.18</i>
widgetGetFontMap :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe FontMap)

-- | Returns the <a>FontOptions</a> used for Pango rendering. When not set,
--   the defaults font options for the <a>Screen</a> will be used.
--   
--   <i>Since: 3.18</i>
widgetGetFontOptions :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe FontOptions)

-- | Gets the value of the <a>Widget:halign</a> property.
--   
--   For backwards compatibility reasons this method will never return
--   <a>AlignBaseline</a>, but instead it will convert it to
--   <a>AlignFill</a>. Baselines are not supported for horizontal
--   alignment.
widgetGetHalign :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Align

-- | Returns the current value of the has-tooltip property. See
--   <a>Widget:hasTooltip</a> for more information.
--   
--   <i>Since: 2.12</i>
widgetGetHasTooltip :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets whether the widget would like any available extra horizontal
--   space. When a user resizes a <a>Window</a>, widgets with expand=TRUE
--   generally receive the extra space. For example, a list or scrollable
--   area or document in your window would often be set to expand.
--   
--   Containers should use <a>widgetComputeExpand</a> rather than this
--   function, to see whether a widget, or any of its children, has the
--   expand flag set. If any child of a widget wants to expand, the parent
--   may ask to expand also.
--   
--   This function only looks at the widget’s own hexpand flag, rather than
--   computing whether the entire widget tree rooted at this widget wants
--   to expand.
widgetGetHexpand :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets whether <a>widgetSetHexpand</a> has been used to explicitly set
--   the expand flag on this widget.
--   
--   If hexpand is set, then it overrides any computed expand value based
--   on child widgets. If hexpand is not set, then the expand value depends
--   on whether any children of the widget would like to expand.
--   
--   There are few reasons to use this function, but it’s here for
--   completeness and consistency.
widgetGetHexpandSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Whether the widget is mapped.
--   
--   <i>Since: 2.20</i>
widgetGetMapped :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets the value of the <a>Widget:marginBottom</a> property.
--   
--   <i>Since: 3.0</i>
widgetGetMarginBottom :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Gets the value of the <a>Widget:marginEnd</a> property.
--   
--   <i>Since: 3.12</i>
widgetGetMarginEnd :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Gets the value of the <a>Widget:marginLeft</a> property.
--   
--   <i>Since: 3.0</i>
widgetGetMarginLeft :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Gets the value of the <a>Widget:marginRight</a> property.
--   
--   <i>Since: 3.0</i>
widgetGetMarginRight :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Gets the value of the <a>Widget:marginStart</a> property.
--   
--   <i>Since: 3.12</i>
widgetGetMarginStart :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Gets the value of the <a>Widget:marginTop</a> property.
--   
--   <i>Since: 3.0</i>
widgetGetMarginTop :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Returns the modifier mask the <i><tt>widget</tt></i>’s windowing
--   system backend uses for a particular purpose.
--   
--   See <a>keymapGetModifierMask</a>.
--   
--   <i>Since: 3.4</i>
widgetGetModifierMask :: (HasCallStack, MonadIO m, IsWidget a) => a -> ModifierIntent -> m [ModifierType]

-- | Returns the current modifier style for the widget. (As set by
--   <a>widgetModifyStyle</a>.) If no style has previously set, a new
--   <a>RcStyle</a> will be created with all values unset, and set as the
--   modifier style for the widget. If you make changes to this rc style,
--   you must call <a>widgetModifyStyle</a>, passing in the returned rc
--   style, to make sure that your changes take effect.
--   
--   Caution: passing the style back to <a>widgetModifyStyle</a> will
--   normally end up destroying it, because <a>widgetModifyStyle</a> copies
--   the passed-in style and sets the copy as the new modifier style, thus
--   dropping any reference to the old modifier style. Add a reference to
--   the modifier style if you want to keep it alive.
widgetGetModifierStyle :: (HasCallStack, MonadIO m, IsWidget a) => a -> m RcStyle

-- | Retrieves the name of a widget. See <a>widgetSetName</a> for the
--   significance of widget names.
widgetGetName :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Text

-- | Returns the current value of the <a>Widget:noShowAll</a> property,
--   which determines whether calls to <a>widgetShowAll</a> will affect
--   this widget.
--   
--   <i>Since: 2.4</i>
widgetGetNoShowAll :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Fetches the requested opacity for this widget. See
--   <a>widgetSetOpacity</a>.
--   
--   <i>Since: 3.8</i>
widgetGetOpacity :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Double

-- | Gets a <a>Context</a> with the appropriate font map, font description,
--   and base direction for this widget. Unlike the context returned by
--   <a>widgetCreatePangoContext</a>, this context is owned by the widget
--   (it can be used until the screen for the widget changes or the widget
--   is removed from its toplevel), and will be updated to match any
--   changes to the widget’s attributes. This can be tracked by using the
--   <a>Widget::screenChanged</a> signal on the widget.
widgetGetPangoContext :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Context

-- | Returns the parent container of <i><tt>widget</tt></i>.
widgetGetParent :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Widget)

-- | Gets <i><tt>widget</tt></i>’s parent window, or <a>Nothing</a> if it
--   does not have one.
widgetGetParentWindow :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Window)

-- | Returns the <a>WidgetPath</a> representing <i><tt>widget</tt></i>, if
--   the widget is not connected to a toplevel widget, a partial path will
--   be created.
widgetGetPath :: (HasCallStack, MonadIO m, IsWidget a) => a -> m WidgetPath

-- | Obtains the location of the mouse pointer in widget coordinates.
--   Widget coordinates are a bit odd; for historical reasons, they are
--   defined as <i><tt>widget</tt></i>-&gt;window coordinates for widgets
--   that return <a>True</a> for <a>widgetGetHasWindow</a>; and are
--   relative to <i><tt>widget</tt></i>-&gt;allocation.x,
--   <i><tt>widget</tt></i>-&gt;allocation.y otherwise.
widgetGetPointer :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Int32, Int32)

-- | Retrieves a widget’s initial minimum and natural height.
--   
--   This call is specific to width-for-height requests.
--   
--   The returned request will be modified by the
--   GtkWidgetClass<a>adjust_size_request</a> virtual method and by any
--   <tt><i>GtkSizeGroups</i></tt> that have been applied. That is, the
--   returned request is the one that should be used for layout, not
--   necessarily the one returned by the widget itself.
--   
--   <i>Since: 3.0</i>
widgetGetPreferredHeight :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Int32, Int32)

-- | Retrieves a widget’s minimum and natural height and the corresponding
--   baselines if it would be given the specified <i><tt>width</tt></i>, or
--   the default height if <i><tt>width</tt></i> is -1. The baselines may
--   be -1 which means that no baseline is requested for this widget.
--   
--   The returned request will be modified by the
--   GtkWidgetClass<a>adjust_size_request</a> and
--   GtkWidgetClass<a>adjust_baseline_request</a> virtual methods and by
--   any <tt><i>GtkSizeGroups</i></tt> that have been applied. That is, the
--   returned request is the one that should be used for layout, not
--   necessarily the one returned by the widget itself.
--   
--   <i>Since: 3.10</i>
widgetGetPreferredHeightAndBaselineForWidth :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m (Int32, Int32, Int32, Int32)

-- | Retrieves a widget’s minimum and natural height if it would be given
--   the specified <i><tt>width</tt></i>.
--   
--   The returned request will be modified by the
--   GtkWidgetClass<a>adjust_size_request</a> virtual method and by any
--   <tt><i>GtkSizeGroups</i></tt> that have been applied. That is, the
--   returned request is the one that should be used for layout, not
--   necessarily the one returned by the widget itself.
--   
--   <i>Since: 3.0</i>
widgetGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m (Int32, Int32)

-- | Retrieves the minimum and natural size of a widget, taking into
--   account the widget’s preference for height-for-width management.
--   
--   This is used to retrieve a suitable size by container widgets which do
--   not impose any restrictions on the child placement. It can be used to
--   deduce toplevel window and menu sizes as well as child widgets in
--   free-form containers such as GtkLayout.
--   
--   Handle with care. Note that the natural height of a height-for-width
--   widget will generally be a smaller size than the minimum height, since
--   the required height for the natural width is generally smaller than
--   the required height for the minimum width.
--   
--   Use <a>widgetGetPreferredHeightAndBaselineForWidth</a> if you want to
--   support baseline alignment.
--   
--   <i>Since: 3.0</i>
widgetGetPreferredSize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Requisition, Requisition)

-- | Retrieves a widget’s initial minimum and natural width.
--   
--   This call is specific to height-for-width requests.
--   
--   The returned request will be modified by the
--   GtkWidgetClass<a>adjust_size_request</a> virtual method and by any
--   <tt><i>GtkSizeGroups</i></tt> that have been applied. That is, the
--   returned request is the one that should be used for layout, not
--   necessarily the one returned by the widget itself.
--   
--   <i>Since: 3.0</i>
widgetGetPreferredWidth :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Int32, Int32)

-- | Retrieves a widget’s minimum and natural width if it would be given
--   the specified <i><tt>height</tt></i>.
--   
--   The returned request will be modified by the
--   GtkWidgetClass<a>adjust_size_request</a> virtual method and by any
--   <tt><i>GtkSizeGroups</i></tt> that have been applied. That is, the
--   returned request is the one that should be used for layout, not
--   necessarily the one returned by the widget itself.
--   
--   <i>Since: 3.0</i>
widgetGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m (Int32, Int32)

-- | Determines whether <i><tt>widget</tt></i> is realized.
--   
--   <i>Since: 2.20</i>
widgetGetRealized :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines whether <i><tt>widget</tt></i> is always treated as the
--   default widget within its toplevel when it has the focus, even if
--   another widget is the default.
--   
--   See <a>widgetSetReceivesDefault</a>.
--   
--   <i>Since: 2.18</i>
widgetGetReceivesDefault :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets whether the widget prefers a height-for-width layout or a
--   width-for-height layout.
--   
--   <a>Bin</a> widgets generally propagate the preference of their child,
--   container widgets need to request something either in context of their
--   children or in context of their allocation capabilities.
--   
--   <i>Since: 3.0</i>
widgetGetRequestMode :: (HasCallStack, MonadIO m, IsWidget a) => a -> m SizeRequestMode

-- | Retrieves the widget’s requisition.
--   
--   This function should only be used by widget implementations in order
--   to figure whether the widget’s requisition has actually changed after
--   some internal state change (so that they can call
--   <a>widgetQueueResize</a> instead of <a>widgetQueueDraw</a>).
--   
--   Normally, <a>widgetSizeRequest</a> should be used.
--   
--   <i>Since: 2.20</i>
widgetGetRequisition :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Requisition

-- | Get the root window where this widget is located. This function can
--   only be called after the widget has been added to a widget hierarchy
--   with <a>Window</a> at the top.
--   
--   The root window is useful for such purposes as creating a popup
--   <a>Window</a> associated with the window. In general, you should only
--   create display specific resources when a widget has been realized, and
--   you should free those resources when the widget is unrealized.
--   
--   <i>Since: 2.2</i>
widgetGetRootWindow :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Window

-- | Retrieves the internal scale factor that maps from window coordinates
--   to the actual device pixels. On traditional systems this is 1, on high
--   density outputs, it can be a higher value (typically 2).
--   
--   See <a>windowGetScaleFactor</a>.
--   
--   <i>Since: 3.10</i>
widgetGetScaleFactor :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Get the <a>Screen</a> from the toplevel window associated with this
--   widget. This function can only be called after the widget has been
--   added to a widget hierarchy with a <a>Window</a> at the top.
--   
--   In general, you should only create screen specific resources when a
--   widget has been realized, and you should free those resources when the
--   widget is unrealized.
--   
--   <i>Since: 2.2</i>
widgetGetScreen :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Screen

-- | Returns the widget’s sensitivity (in the sense of returning the value
--   that has been set using <a>widgetSetSensitive</a>).
--   
--   The effective sensitivity of a widget is however determined by both
--   its own and its parent widget’s sensitivity. See
--   <a>widgetIsSensitive</a>.
--   
--   <i>Since: 2.18</i>
widgetGetSensitive :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets the settings object holding the settings used for this widget.
--   
--   Note that this function can only be called when the <a>Widget</a> is
--   attached to a toplevel, since the settings object is specific to a
--   particular <a>Screen</a>.
widgetGetSettings :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Settings

-- | Gets the size request that was explicitly set for the widget using
--   <a>widgetSetSizeRequest</a>. A value of -1 stored in
--   <i><tt>width</tt></i> or <i><tt>height</tt></i> indicates that that
--   dimension has not been set explicitly and the natural requisition of
--   the widget will be used instead. See <a>widgetSetSizeRequest</a>. To
--   get the size a widget will actually request, call
--   <a>widgetGetPreferredSize</a> instead of this function.
widgetGetSizeRequest :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Int32, Int32)

-- | Returns the widget’s state. See <a>widgetSetState</a>.
--   
--   <i>Since: 2.18</i>
widgetGetState :: (HasCallStack, MonadIO m, IsWidget a) => a -> m StateType

-- | Simply an accessor function that returns
--   <i><tt>widget</tt></i>-&gt;style.
widgetGetStyle :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Style

-- | Returns <a>True</a> if <i><tt>widget</tt></i> is multiple pointer
--   aware. See <a>widgetSetSupportMultidevice</a> for more information.
widgetGetSupportMultidevice :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets the contents of the tooltip for <i><tt>widget</tt></i>.
--   
--   <i>Since: 2.12</i>
widgetGetTooltipMarkup :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Text)

-- | Gets the contents of the tooltip for <i><tt>widget</tt></i>.
--   
--   <i>Since: 2.12</i>
widgetGetTooltipText :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Text)

-- | Returns the <a>Window</a> of the current tooltip. This can be the
--   GtkWindow created by default, or the custom tooltip window set using
--   <a>widgetSetTooltipWindow</a>.
--   
--   <i>Since: 2.12</i>
widgetGetTooltipWindow :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Window

-- | This function returns the topmost widget in the container hierarchy
--   <i><tt>widget</tt></i> is a part of. If <i><tt>widget</tt></i> has no
--   parent widgets, it will be returned as the topmost widget. No
--   reference will be added to the returned widget; it should not be
--   unreferenced.
--   
--   Note the difference in behavior vs. <a>widgetGetAncestor</a>;
--   <tt>gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)</tt> would
--   return <a>Nothing</a> if <i><tt>widget</tt></i> wasn’t inside a
--   toplevel window, and if the window was inside a <a>Window</a>-derived
--   widget which was in turn inside the toplevel <a>Window</a>. While the
--   second case may seem unlikely, it actually happens when a <a>Plug</a>
--   is embedded inside a <a>Socket</a> within the same application.
--   
--   To reliably find the toplevel <a>Window</a>, use
--   <a>widgetGetToplevel</a> and call <tt><i>GTK_IS_WINDOW()</i></tt> on
--   the result. For instance, to get the title of a widget's toplevel
--   window, one might use:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   static const char *
--   get_widget_toplevel_title (GtkWidget *widget)
--   {
--     GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
--     if (GTK_IS_WINDOW (toplevel))
--       {
--         return gtk_window_get_title (GTK_WINDOW (toplevel));
--       }
--   
--     return NULL;
--   }
--   </pre>
widgetGetToplevel :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Widget

-- | Gets the value of the <a>Widget:valign</a> property.
--   
--   For backwards compatibility reasons this method will never return
--   <a>AlignBaseline</a>, but instead it will convert it to
--   <a>AlignFill</a>. If your widget want to support baseline aligned
--   children it must use <a>widgetGetValignWithBaseline</a>, or
--   <tt>g_object_get (widget, "valign", &amp;value, NULL)</tt>, which will
--   also report the true value.
widgetGetValign :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Align

-- | Gets the value of the <a>Widget:valign</a> property, including
--   <a>AlignBaseline</a>.
--   
--   <i>Since: 3.10</i>
widgetGetValignWithBaseline :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Align

-- | Gets whether the widget would like any available extra vertical space.
--   
--   See <a>widgetGetHexpand</a> for more detail.
widgetGetVexpand :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets whether <a>widgetSetVexpand</a> has been used to explicitly set
--   the expand flag on this widget.
--   
--   See <a>widgetGetHexpandSet</a> for more detail.
widgetGetVexpandSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines whether the widget is visible. If you want to take into
--   account whether the widget’s parent is also marked as visible, use
--   <a>widgetIsVisible</a> instead.
--   
--   This function does not check if the widget is obscured in any way.
--   
--   See <a>widgetSetVisible</a>.
--   
--   <i>Since: 2.18</i>
widgetGetVisible :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets the visual that will be used to render <i><tt>widget</tt></i>.
widgetGetVisual :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Visual

-- | Returns the widget’s window if it is realized, <a>Nothing</a>
--   otherwise
--   
--   <i>Since: 2.14</i>
widgetGetWindow :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Window)

-- | Removes the grab from the given widget.
--   
--   You have to pair calls to <a>widgetGrabAdd</a> and
--   <a>widgetGrabRemove</a>.
--   
--   If <i><tt>widget</tt></i> does not have the grab, this function does
--   nothing.
widgetGrabRemove :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Determines whether <i><tt>widget</tt></i> is the current default
--   widget within its toplevel. See <a>widgetSetCanDefault</a>.
--   
--   <i>Since: 2.18</i>
widgetHasDefault :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines if the widget has the global input focus. See
--   <a>widgetIsFocus</a> for the difference between having the global
--   input focus, and only having the focus within a toplevel.
--   
--   <i>Since: 2.18</i>
widgetHasFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines whether the widget is currently grabbing events, so it is
--   the only widget receiving input events (keyboard and mouse).
--   
--   See also <a>widgetGrabAdd</a>.
--   
--   <i>Since: 2.18</i>
widgetHasGrab :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines if the widget style has been looked up through the rc
--   mechanism.
--   
--   <i>Since: 2.20</i>
widgetHasRcStyle :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Checks whether there is a <a>Screen</a> is associated with this
--   widget. All toplevel widgets have an associated screen, and all
--   widgets added into a hierarchy with a toplevel window at the top.
--   
--   <i>Since: 2.2</i>
widgetHasScreen :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines if the widget should show a visible indication that it has
--   the global input focus. This is a convenience function for use in
--   <a>draw</a> handlers that takes into account whether focus indication
--   should currently be shown in the toplevel window of
--   <i><tt>widget</tt></i>. See <a>windowGetFocusVisible</a> for more
--   information about focus indication.
--   
--   To find out if the widget has the global input focus, use
--   <a>widgetHasFocus</a>.
--   
--   <i>Since: 3.2</i>
widgetHasVisibleFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Utility function; intended to be connected to the
--   <a>Widget::deleteEvent</a> signal on a <a>Window</a>. The function
--   calls <a>widgetHide</a> on its argument, then returns <a>True</a>. If
--   connected to <a>deleteEvent</a>, the result is that clicking the close
--   button for a window (on the window frame, top right corner usually)
--   will hide but not destroy the window. By default, GTK+ destroys
--   windows when <a>deleteEvent</a> is received.
widgetHideOnDelete :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Returns whether the widget is currently being destroyed. This
--   information can sometimes be used to avoid doing unnecessary work.
widgetInDestruction :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Sets an input shape for this widget’s GDK window. This allows for
--   windows which react to mouse click in a nonrectangular region, see
--   <a>windowInputShapeCombineRegion</a> for more information.
--   
--   <i>Since: 3.0</i>
widgetInputShapeCombineRegion :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Region -> m ()

-- | Computes the intersection of a <i><tt>widget</tt></i>’s area and
--   <i><tt>area</tt></i>, storing the intersection in
--   <i><tt>intersection</tt></i>, and returns <a>True</a> if there was an
--   intersection. <i><tt>intersection</tt></i> may be <a>Nothing</a> if
--   you’re only interested in whether there was an intersection.
widgetIntersect :: (HasCallStack, MonadIO m, IsWidget a) => a -> Rectangle -> m (Bool, Maybe Rectangle)

-- | Determines whether <i><tt>widget</tt></i> is somewhere inside
--   <i><tt>ancestor</tt></i>, possibly with intermediate containers.
widgetIsAncestor :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m Bool

-- | Determines whether <i><tt>widget</tt></i> can be drawn to. A widget
--   can be drawn to if it is mapped and visible.
--   
--   <i>Since: 2.18</i>
widgetIsDrawable :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines if the widget is the focus widget within its toplevel.
--   (This does not mean that the <a>Widget:hasFocus</a> property is
--   necessarily set; <a>Widget:hasFocus</a> will only be set if the
--   toplevel widget additionally has the global input focus.)
widgetIsFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Returns the widget’s effective sensitivity, which means it is
--   sensitive itself and also its parent widget is sensitive
--   
--   <i>Since: 2.18</i>
widgetIsSensitive :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines whether <i><tt>widget</tt></i> is a toplevel widget.
--   
--   Currently only <a>Window</a> and <a>Invisible</a> (and out-of-process
--   <tt><i>GtkPlugs</i></tt>) are toplevel widgets. Toplevel widgets have
--   no parent widget.
--   
--   <i>Since: 2.18</i>
widgetIsToplevel :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines whether the widget and all its parents are marked as
--   visible.
--   
--   This function does not check if the widget is obscured in any way.
--   
--   See also <a>widgetGetVisible</a> and <a>widgetSetVisible</a>
--   
--   <i>Since: 3.8</i>
widgetIsVisible :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | This function should be called whenever keyboard navigation within a
--   single widget hits a boundary. The function emits the
--   <a>Widget::keynavFailed</a> signal on the widget and its return value
--   should be interpreted in a way similar to the return value of
--   <a>widgetChildFocus</a>:
--   
--   When <a>True</a> is returned, stay in the widget, the failed keyboard
--   navigation is OK and/or there is nowhere we can/should move the focus
--   to.
--   
--   When <a>False</a> is returned, the caller should continue with
--   keyboard navigation outside the widget, e.g. by calling
--   <a>widgetChildFocus</a> on the widget’s toplevel.
--   
--   The default <a>keynavFailed</a> handler returns <a>False</a> for
--   <a>DirectionTypeTabForward</a> and <a>DirectionTypeTabBackward</a>.
--   For the other values of <a>DirectionType</a> it returns <a>True</a>.
--   
--   Whenever the default handler returns <a>True</a>, it also calls
--   <a>widgetErrorBell</a> to notify the user of the failed keyboard
--   navigation.
--   
--   A use case for providing an own implementation of <a>keynavFailed</a>
--   (either by connecting to it or by overriding it) would be a row of
--   <a>Entry</a> widgets where the user should be able to navigate the
--   entire row with the cursor keys, as e.g. known from user interfaces
--   that require entering license keys.
--   
--   <i>Since: 2.12</i>
widgetKeynavFailed :: (HasCallStack, MonadIO m, IsWidget a) => a -> DirectionType -> m Bool

-- | Lists the closures used by <i><tt>widget</tt></i> for accelerator
--   group connections with <a>accelGroupConnectByPath</a> or
--   <a>accelGroupConnect</a>. The closures can be used to monitor
--   accelerator changes on <i><tt>widget</tt></i>, by connecting to the
--   <i><tt>gtkAccelGroup</tt></i><a>accelChanged</a> signal of the
--   <a>AccelGroup</a> of a closure which can be found out with
--   <a>accelGroupFromAccelClosure</a>.
widgetListAccelClosures :: (HasCallStack, MonadIO m, IsWidget a) => a -> m [GClosure b]

-- | Retrieves a <a>Nothing</a>-terminated array of strings containing the
--   prefixes of <a>ActionGroup</a>'s available to <i><tt>widget</tt></i>.
--   
--   <i>Since: 3.16</i>
widgetListActionPrefixes :: (HasCallStack, MonadIO m, IsWidget a) => a -> m [Text]

-- | Returns a newly allocated list of the widgets, normally labels, for
--   which this widget is the target of a mnemonic (see for example,
--   <a>labelSetMnemonicWidget</a>).
--   
--   The widgets in the list are not individually referenced. If you want
--   to iterate through the list and perform actions involving callbacks
--   that might destroy the widgets, you must call <tt>g_list_foreach
--   (result, (GFunc)g_object_ref, NULL)</tt> first, and then unref all the
--   widgets afterwards.
--   
--   <i>Since: 2.4</i>
widgetListMnemonicLabels :: (HasCallStack, MonadIO m, IsWidget a) => a -> m [Widget]

-- | This function is only for use in widget implementations. Causes a
--   widget to be mapped if it isn’t already.
widgetMap :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Emits the <a>Widget::mnemonicActivate</a> signal.
widgetMnemonicActivate :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m Bool

-- | Sets the base color for a widget in a particular state. All other
--   style values are left untouched. The base color is the background
--   color used along with the text color (see <a>widgetModifyText</a>) for
--   widgets such as <a>Entry</a> and <a>TextView</a>. See also
--   <a>widgetModifyStyle</a>.
--   
--   <pre>
--   Note that “no window” widgets (which have the @/GTK_NO_WINDOW/@
--   flag set) draw on their parent container’s window and thus may
--   not draw any background themselves. This is the case for e.g.
--   t'GI.Gtk.Objects.Label.Label'.
--   
--   To modify the background of such widgets, you have to set the
--   base color on their parent; if you want to set the background
--   of a rectangular area around a label, try placing the label in
--   a t'GI.Gtk.Objects.EventBox.EventBox' widget and setting the base color on that.
--   </pre>
widgetModifyBase :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> Maybe Color -> m ()

-- | Sets the background color for a widget in a particular state.
--   
--   All other style values are left untouched. See also
--   <a>widgetModifyStyle</a>.
--   
--   <pre>
--   Note that “no window” widgets (which have the @/GTK_NO_WINDOW/@
--   flag set) draw on their parent container’s window and thus may
--   not draw any background themselves. This is the case for e.g.
--   t'GI.Gtk.Objects.Label.Label'.
--   
--   To modify the background of such widgets, you have to set the
--   background color on their parent; if you want to set the background
--   of a rectangular area around a label, try placing the label in
--   a t'GI.Gtk.Objects.EventBox.EventBox' widget and setting the background color on that.
--   </pre>
widgetModifyBg :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> Maybe Color -> m ()

-- | Sets the cursor color to use in a widget, overriding the <a>Widget</a>
--   cursor-color and secondary-cursor-color style properties.
--   
--   All other style values are left untouched. See also
--   <a>widgetModifyStyle</a>.
--   
--   <i>Since: 2.12</i>
widgetModifyCursor :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Color -> Maybe Color -> m ()

-- | Sets the foreground color for a widget in a particular state.
--   
--   All other style values are left untouched. See also
--   <a>widgetModifyStyle</a>.
widgetModifyFg :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> Maybe Color -> m ()

-- | Sets the font to use for a widget.
--   
--   All other style values are left untouched. See also
--   <a>widgetModifyStyle</a>.
widgetModifyFont :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe FontDescription -> m ()

-- | Modifies style values on the widget.
--   
--   Modifications made using this technique take precedence over style
--   values set via an RC file, however, they will be overridden if a style
--   is explicitly set on the widget using <a>widgetSetStyle</a>. The
--   <a>RcStyle</a>-struct is designed so each field can either be set or
--   unset, so it is possible, using this function, to modify some style
--   values and leave the others unchanged.
--   
--   Note that modifications made with this function are not cumulative
--   with previous calls to <a>widgetModifyStyle</a> or with such functions
--   as <a>widgetModifyFg</a>. If you wish to retain previous values, you
--   must first call <a>widgetGetModifierStyle</a>, make your modifications
--   to the returned style, then call <a>widgetModifyStyle</a> with that
--   style. On the other hand, if you first call <a>widgetModifyStyle</a>,
--   subsequent calls to such functions <a>widgetModifyFg</a> will have a
--   cumulative effect with the initial modifications.
widgetModifyStyle :: (HasCallStack, MonadIO m, IsWidget a, IsRcStyle b) => a -> b -> m ()

-- | Sets the text color for a widget in a particular state.
--   
--   All other style values are left untouched. The text color is the
--   foreground color used along with the base color (see
--   <a>widgetModifyBase</a>) for widgets such as <a>Entry</a> and
--   <a>TextView</a>. See also <a>widgetModifyStyle</a>.
widgetModifyText :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> Maybe Color -> m ()

-- | Sets the background color to use for a widget.
--   
--   All other style values are left untouched. See
--   <a>widgetOverrideColor</a>.
--   
--   <i>Since: 3.0</i>
widgetOverrideBackgroundColor :: (HasCallStack, MonadIO m, IsWidget a) => a -> [StateFlags] -> Maybe RGBA -> m ()

-- | Sets the color to use for a widget.
--   
--   All other style values are left untouched.
--   
--   This function does not act recursively. Setting the color of a
--   container does not affect its children. Note that some widgets that
--   you may not think of as containers, for instance
--   <tt><i>GtkButtons</i></tt>, are actually containers.
--   
--   This API is mostly meant as a quick way for applications to change a
--   widget appearance. If you are developing a widgets library and intend
--   this change to be themeable, it is better done by setting meaningful
--   CSS classes in your widget/container implementation through
--   <a>styleContextAddClass</a>.
--   
--   This way, your widget library can install a <a>CssProvider</a> with
--   the <a>STYLE_PROVIDER_PRIORITY_FALLBACK</a> priority in order to
--   provide a default styling for those widgets that need so, and this
--   theming may fully overridden by the user’s theme.
--   
--   Note that for complex widgets this may bring in undesired results
--   (such as uniform background color everywhere), in these cases it is
--   better to fully style such widgets through a <a>CssProvider</a> with
--   the <a>STYLE_PROVIDER_PRIORITY_APPLICATION</a> priority.
--   
--   <i>Since: 3.0</i>
widgetOverrideColor :: (HasCallStack, MonadIO m, IsWidget a) => a -> [StateFlags] -> Maybe RGBA -> m ()

-- | Sets the cursor color to use in a widget, overriding the cursor-color
--   and secondary-cursor-color style properties. All other style values
--   are left untouched. See also <a>widgetModifyStyle</a>.
--   
--   Note that the underlying properties have the <a>Color</a> type, so the
--   alpha value in <i><tt>primary</tt></i> and <i><tt>secondary</tt></i>
--   will be ignored.
--   
--   <i>Since: 3.0</i>
widgetOverrideCursor :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe RGBA -> Maybe RGBA -> m ()

-- | Sets the font to use for a widget. All other style values are left
--   untouched. See <a>widgetOverrideColor</a>.
--   
--   <i>Since: 3.0</i>
widgetOverrideFont :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe FontDescription -> m ()

-- | Sets a symbolic color for a widget.
--   
--   All other style values are left untouched. See
--   <a>widgetOverrideColor</a> for overriding the foreground or background
--   color.
--   
--   <i>Since: 3.0</i>
widgetOverrideSymbolicColor :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> Maybe RGBA -> m ()

-- | Obtains the full path to <i><tt>widget</tt></i>. The path is simply
--   the name of a widget and all its parents in the container hierarchy,
--   separated by periods. The name of a widget comes from
--   <a>widgetGetName</a>. Paths are used to apply styles to a widget in
--   gtkrc configuration files. Widget names are the type of the widget by
--   default (e.g. “GtkButton”) or can be set to an application-specific
--   value with <a>widgetSetName</a>. By setting the name of a widget, you
--   allow users or theme authors to apply styles to that specific widget
--   in their gtkrc file. <i><tt>pathReversedP</tt></i> fills in the path
--   in reverse order, i.e. starting with <i><tt>widget</tt></i>’s name
--   instead of starting with the name of <i><tt>widget</tt></i>’s
--   outermost ancestor.
widgetPath :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Word32, Text, Text)

-- | This function is only for use in widget implementations.
--   
--   Flags the widget for a rerun of the GtkWidgetClass<a>size_allocate</a>
--   function. Use this function instead of <a>widgetQueueResize</a> when
--   the <i><tt>widget</tt></i>'s size request didn't change but it wants
--   to reposition its contents.
--   
--   An example user of this function is <a>widgetSetHalign</a>.
--   
--   <i>Since: 3.20</i>
widgetQueueAllocate :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Mark <i><tt>widget</tt></i> as needing to recompute its expand flags.
--   Call this function when setting legacy expand child properties on the
--   child of a container.
--   
--   See <a>widgetComputeExpand</a>.
widgetQueueComputeExpand :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Convenience function that calls <a>widgetQueueDrawRegion</a> on the
--   region created from the given coordinates.
--   
--   The region here is specified in widget coordinates. Widget coordinates
--   are a bit odd; for historical reasons, they are defined as
--   <i><tt>widget</tt></i>-&gt;window coordinates for widgets that return
--   <a>True</a> for <a>widgetGetHasWindow</a>, and are relative to
--   <i><tt>widget</tt></i>-&gt;allocation.x,
--   <i><tt>widget</tt></i>-&gt;allocation.y otherwise.
--   
--   <i><tt>width</tt></i> or <i><tt>height</tt></i> may be 0, in this case
--   this function does nothing. Negative values for <i><tt>width</tt></i>
--   and <i><tt>height</tt></i> are not allowed.
widgetQueueDrawArea :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Invalidates the area of <i><tt>widget</tt></i> defined by
--   <i><tt>region</tt></i> by calling <a>windowInvalidateRegion</a> on the
--   widget’s window and all its child windows. Once the main loop becomes
--   idle (after the current batch of events has been processed, roughly),
--   the window will receive expose events for the union of all regions
--   that have been invalidated.
--   
--   Normally you would only use this function in widget implementations.
--   You might also use it to schedule a redraw of a <a>DrawingArea</a> or
--   some portion thereof.
--   
--   <i>Since: 3.0</i>
widgetQueueDrawRegion :: (HasCallStack, MonadIO m, IsWidget a) => a -> Region -> m ()

-- | This function is only for use in widget implementations. Flags a
--   widget to have its size renegotiated; should be called when a widget
--   for some reason has a new size request. For example, when you change
--   the text in a <a>Label</a>, <a>Label</a> queues a resize to ensure
--   there’s enough space for the new text.
--   
--   Note that you cannot call <a>widgetQueueResize</a> on a widget from
--   inside its implementation of the GtkWidgetClass<a>size_allocate</a>
--   virtual method. Calls to <a>widgetQueueResize</a> from inside
--   GtkWidgetClass<a>size_allocate</a> will be silently ignored.
widgetQueueResize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | This function works like <a>widgetQueueResize</a>, except that the
--   widget is not invalidated.
--   
--   <i>Since: 2.4</i>
widgetQueueResizeNoRedraw :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Creates the GDK (windowing system) resources associated with a widget.
--   For example, <i><tt>widget</tt></i>-&gt;window will be created when a
--   widget is realized. Normally realization happens implicitly; if you
--   show a widget and all its parent containers, then the widget will be
--   realized and mapped automatically.
--   
--   Realizing a widget requires all the widget’s parent widgets to be
--   realized; calling <a>widgetRealize</a> realizes the widget’s parents
--   in addition to <i><tt>widget</tt></i> itself. If a widget is not yet
--   inside a toplevel window when you realize it, bad things will happen.
--   
--   This function is primarily used in widget implementations, and isn’t
--   very useful otherwise. Many times when you think you might need it, a
--   better approach is to connect to a signal that will be called after
--   the widget is realized automatically, such as <a>Widget::draw</a>. Or
--   simply g_signal_connect () to the <a>Widget::realize</a> signal.
widgetRealize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Computes the intersection of a <i><tt>widget</tt></i>’s area and
--   <i><tt>region</tt></i>, returning the intersection. The result may be
--   empty, use <tt><i>cairo_region_is_empty()</i></tt> to check.
widgetRegionIntersect :: (HasCallStack, MonadIO m, IsWidget a) => a -> Region -> m Region

-- | Registers a <a>Window</a> with the widget and sets it up so that the
--   widget receives events for it. Call <a>widgetUnregisterWindow</a> when
--   destroying the window.
--   
--   Before 3.8 you needed to call <a>windowSetUserData</a> directly to set
--   this up. This is now deprecated and you should use
--   <a>widgetRegisterWindow</a> instead. Old code will keep working as is,
--   although some new features like transparency might not work perfectly.
--   
--   <i>Since: 3.8</i>
widgetRegisterWindow :: (HasCallStack, MonadIO m, IsWidget a, IsWindow b) => a -> b -> m ()

-- | Removes an accelerator from <i><tt>widget</tt></i>, previously
--   installed with <a>widgetAddAccelerator</a>.
widgetRemoveAccelerator :: (HasCallStack, MonadIO m, IsWidget a, IsAccelGroup b) => a -> b -> Word32 -> [ModifierType] -> m Bool

-- | Removes a widget from the list of mnemonic labels for this widget.
--   (See <a>widgetListMnemonicLabels</a>). The widget must have previously
--   been added to the list with <a>widgetAddMnemonicLabel</a>.
--   
--   <i>Since: 2.4</i>
widgetRemoveMnemonicLabel :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m ()

-- | Removes a tick callback previously registered with
--   <a>widgetAddTickCallback</a>.
--   
--   <i>Since: 3.8</i>
widgetRemoveTickCallback :: (HasCallStack, MonadIO m, IsWidget a) => a -> Word32 -> m ()

-- | Moves a widget from one <a>Container</a> to another, handling
--   reference count issues to avoid destroying the widget.
widgetReparent :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m ()

-- | Reset the styles of <i><tt>widget</tt></i> and all descendents, so
--   when they are looked up again, they get the correct values for the
--   currently loaded RC file settings.
--   
--   This function is not useful for applications.
widgetResetRcStyles :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Very rarely-used function. This function is used to emit an expose
--   event on a widget. This function is not normally used directly. The
--   only time it is used is when propagating an expose event to a
--   windowless child widget (<a>widgetGetHasWindow</a> is <a>False</a>),
--   and that is normally done using <a>containerPropagateDraw</a>.
--   
--   If you want to force an area of a window to be redrawn, use
--   <a>windowInvalidateRect</a> or <a>windowInvalidateRegion</a>. To cause
--   the redraw to be done immediately, follow that call with a call to
--   <a>windowProcessUpdates</a>.
widgetSendExpose :: (HasCallStack, MonadIO m, IsWidget a) => a -> Event -> m Int32

-- | Sends the focus change <i><tt>event</tt></i> to <i><tt>widget</tt></i>
--   
--   This function is not meant to be used by applications. The only time
--   it should be used is when it is necessary for a <a>Widget</a> to
--   assign focus to a widget that is semantically owned by the first
--   widget even though it’s not a direct child - for instance, a search
--   entry in a floating window similar to the quick search in
--   <a>TreeView</a>.
--   
--   An example of its usage is:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
--   
--   fevent-&gt;focus_change.type = GDK_FOCUS_CHANGE;
--   fevent-&gt;focus_change.in = TRUE;
--   fevent-&gt;focus_change.window = _gtk_widget_get_window (widget);
--   if (fevent-&gt;focus_change.window != NULL)
--     g_object_ref (fevent-&gt;focus_change.window);
--   
--   gtk_widget_send_focus_change (widget, fevent);
--   
--   gdk_event_free (event);
--   </pre>
--   
--   <i>Since: 2.20</i>
widgetSendFocusChange :: (HasCallStack, MonadIO m, IsWidget a) => a -> Event -> m Bool

-- | Sets the widget’s allocation. This should not be used directly, but
--   from within a widget’s size_allocate method.
--   
--   The allocation set should be the “adjusted” or actual allocation. If
--   you’re implementing a <a>Container</a>, you want to use
--   <a>widgetSizeAllocate</a> instead of <a>widgetSetAllocation</a>. The
--   GtkWidgetClass<a>adjust_size_allocation</a> virtual method adjusts the
--   allocation inside <a>widgetSizeAllocate</a> to create an adjusted
--   allocation.
--   
--   <i>Since: 2.18</i>
widgetSetAllocation :: (HasCallStack, MonadIO m, IsWidget a) => a -> Rectangle -> m ()

-- | Sets whether the application intends to draw on the widget in an
--   <a>Widget::draw</a> handler.
--   
--   This is a hint to the widget and does not affect the behavior of the
--   GTK+ core; many widgets ignore this flag entirely. For widgets that do
--   pay attention to the flag, such as <a>EventBox</a> and <a>Window</a>,
--   the effect is to suppress default themed drawing of the widget's
--   background. (Children of the widget will still be drawn.) The
--   application is then entirely responsible for drawing the widget
--   background.
--   
--   Note that the background is still drawn when the widget is mapped.
widgetSetAppPaintable :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Specifies whether <i><tt>widget</tt></i> can own the input focus. See
--   <a>widgetGrabFocus</a> for actually setting the input focus on a
--   widget.
--   
--   <i>Since: 2.18</i>
widgetSetCanFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets whether <i><tt>widget</tt></i> should be mapped along with its
--   when its parent is mapped and <i><tt>widget</tt></i> has been shown
--   with <a>widgetShow</a>.
--   
--   The child visibility can be set for widget before it is added to a
--   container with <a>widgetSetParent</a>, to avoid mapping children
--   unnecessary before immediately unmapping them. However it will be
--   reset to its default state of <a>True</a> when the widget is removed
--   from a container.
--   
--   Note that changing the child visibility of a widget does not queue a
--   resize on the widget. Most of the time, the size of a widget is
--   computed from all visible children, whether or not they are mapped. If
--   this is not the case, the container can queue a resize itself.
--   
--   This function is only useful for container implementations and never
--   should be called by an application.
widgetSetChildVisible :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the widget’s clip. This must not be used directly, but from
--   within a widget’s size_allocate method. It must be called after
--   <a>widgetSetAllocation</a> (or after chaining up to the parent class),
--   because that function resets the clip.
--   
--   The clip set should be the area that <i><tt>widget</tt></i> draws on.
--   If <i><tt>widget</tt></i> is a <a>Container</a>, the area must contain
--   all children's clips.
--   
--   If this function is not called by <i><tt>widget</tt></i> during a
--   <a>sizeAllocate</a> handler, the clip will be set to
--   <i><tt>widget</tt></i>'s allocation.
--   
--   <i>Since: 3.14</i>
widgetSetClip :: (HasCallStack, MonadIO m, IsWidget a) => a -> Rectangle -> m ()

-- | Sets a widgets composite name. The widget must be a composite child of
--   its parent; see <a>widgetPushCompositeChild</a>.
widgetSetCompositeName :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> m ()

-- | Enables or disables a <a>Device</a> to interact with
--   <i><tt>widget</tt></i> and all its children.
--   
--   It does so by descending through the <a>Window</a> hierarchy and
--   enabling the same mask that is has for core events (i.e. the one that
--   <a>windowGetEvents</a> returns).
--   
--   <i>Since: 3.0</i>
widgetSetDeviceEnabled :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> Bool -> m ()

-- | Sets the device event mask (see <a>EventMask</a>) for a widget. The
--   event mask determines which events a widget will receive from
--   <i><tt>device</tt></i>. Keep in mind that different widgets have
--   different default event masks, and by changing the event mask you may
--   disrupt a widget’s functionality, so be careful. This function must be
--   called while a widget is unrealized. Consider
--   <a>widgetAddDeviceEvents</a> for widgets that are already realized, or
--   if you want to preserve the existing event mask. This function can’t
--   be used with windowless widgets (which return <a>False</a> from
--   <a>widgetGetHasWindow</a>); to get events on those widgets, place them
--   inside a <a>EventBox</a> and receive events on the event box.
--   
--   <i>Since: 3.0</i>
widgetSetDeviceEvents :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> [EventMask] -> m ()

-- | Widgets are double buffered by default; you can use this function to
--   turn off the buffering. “Double buffered” simply means that
--   <a>windowBeginDrawFrame</a> and <a>windowEndDrawFrame</a> are called
--   automatically around expose events sent to the widget.
--   <a>windowBeginDrawFrame</a> diverts all drawing to a widget's window
--   to an offscreen buffer, and <a>windowEndDrawFrame</a> draws the buffer
--   to the screen. The result is that users see the window update in one
--   smooth step, and don’t see individual graphics primitives being
--   rendered.
--   
--   In very simple terms, double buffered widgets don’t flicker, so you
--   would only use this function to turn off double buffering if you had
--   special needs and really knew what you were doing.
--   
--   Note: if you turn off double-buffering, you have to handle expose
--   events, since even the clearing to the background color or pixmap will
--   not happen automatically (as it is done in
--   <a>windowBeginDrawFrame</a>).
--   
--   In 3.10 GTK and GDK have been restructured for translucent drawing.
--   Since then expose events for double-buffered widgets are culled into a
--   single event to the toplevel GDK window. If you now unset double
--   buffering, you will cause a separate rendering pass for every widget.
--   This will likely cause rendering problems - in particular related to
--   stacking - and usually increases rendering times significantly.
widgetSetDoubleBuffered :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the event mask (see <a>EventMask</a>) for a widget. The event
--   mask determines which events a widget will receive. Keep in mind that
--   different widgets have different default event masks, and by changing
--   the event mask you may disrupt a widget’s functionality, so be
--   careful. This function must be called while a widget is unrealized.
--   Consider <a>widgetAddEvents</a> for widgets that are already realized,
--   or if you want to preserve the existing event mask. This function
--   can’t be used with widgets that have no window. (See
--   <a>widgetGetHasWindow</a>). To get events on those widgets, place them
--   inside a <a>EventBox</a> and receive events on the event box.
widgetSetEvents :: (HasCallStack, MonadIO m, IsWidget a) => a -> [EventMask] -> m ()

-- | Sets whether the widget should grab focus when it is clicked with the
--   mouse. Making mouse clicks not grab focus is useful in places like
--   toolbars where you don’t want the keyboard focus removed from the main
--   area of the application.
--   
--   <i>Since: 3.20</i>
widgetSetFocusOnClick :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the font map to use for Pango rendering. When not set, the widget
--   will inherit the font map from its parent.
--   
--   <i>Since: 3.18</i>
widgetSetFontMap :: (HasCallStack, MonadIO m, IsWidget a, IsFontMap b) => a -> Maybe b -> m ()

-- | Sets the <a>FontOptions</a> used for Pango rendering in this widget.
--   When not set, the default font options for the <a>Screen</a> will be
--   used.
--   
--   <i>Since: 3.18</i>
widgetSetFontOptions :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe FontOptions -> m ()

-- | Specifies whether <i><tt>widget</tt></i> has a <a>Window</a> of its
--   own. Note that all realized widgets have a non-<a>Nothing</a> “window”
--   pointer (<a>widgetGetWindow</a> never returns a <a>Nothing</a> window
--   when a widget is realized), but for many of them it’s actually the
--   <a>Window</a> of one of its parent widgets. Widgets that do not create
--   a <tt><i>window</i></tt> for themselves in <a>Widget::realize</a> must
--   announce this by calling this function with <i><tt>hasWindow</tt></i>
--   = <a>False</a>.
--   
--   This function should only be called by widget implementations, and
--   they should call it in their <tt><i>init()</i></tt> function.
--   
--   <i>Since: 2.18</i>
widgetSetHasWindow :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets whether the widget would like any available extra horizontal
--   space. When a user resizes a <a>Window</a>, widgets with expand=TRUE
--   generally receive the extra space. For example, a list or scrollable
--   area or document in your window would often be set to expand.
--   
--   Call this function to set the expand flag if you would like your
--   widget to become larger horizontally when the window has extra room.
--   
--   By default, widgets automatically expand if any of their children want
--   to expand. (To see if a widget will automatically expand given its
--   current children and state, call <a>widgetComputeExpand</a>. A
--   container can decide how the expandability of children affects the
--   expansion of the container by overriding the compute_expand virtual
--   method on <a>Widget</a>.).
--   
--   Setting hexpand explicitly with this function will override the
--   automatic expand behavior.
--   
--   This function forces the widget to expand or not to expand, regardless
--   of children. The override occurs because <a>widgetSetHexpand</a> sets
--   the hexpand-set property (see <a>widgetSetHexpandSet</a>) which causes
--   the widget’s hexpand value to be used, rather than looking at children
--   and widget state.
widgetSetHexpand :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets whether the hexpand flag (see <a>widgetGetHexpand</a>) will be
--   used.
--   
--   The hexpand-set property will be set automatically when you call
--   <a>widgetSetHexpand</a> to set hexpand, so the most likely reason to
--   use this function would be to unset an explicit expand flag.
--   
--   If hexpand is set, then it overrides any computed expand value based
--   on child widgets. If hexpand is not set, then the expand value depends
--   on whether any children of the widget would like to expand.
--   
--   There are few reasons to use this function, but it’s here for
--   completeness and consistency.
widgetSetHexpandSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Marks the widget as being mapped.
--   
--   This function should only ever be called in a derived widget's “map”
--   or “unmap” implementation.
--   
--   <i>Since: 2.20</i>
widgetSetMapped :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the bottom margin of <i><tt>widget</tt></i>. See the
--   <a>Widget:marginBottom</a> property.
--   
--   <i>Since: 3.0</i>
widgetSetMarginBottom :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ()

-- | Sets the end margin of <i><tt>widget</tt></i>. See the
--   <a>Widget:marginEnd</a> property.
--   
--   <i>Since: 3.12</i>
widgetSetMarginEnd :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ()

-- | Sets the left margin of <i><tt>widget</tt></i>. See the
--   <a>Widget:marginLeft</a> property.
--   
--   <i>Since: 3.0</i>
widgetSetMarginLeft :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ()

-- | Sets the right margin of <i><tt>widget</tt></i>. See the
--   <a>Widget:marginRight</a> property.
--   
--   <i>Since: 3.0</i>
widgetSetMarginRight :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ()

-- | Sets the start margin of <i><tt>widget</tt></i>. See the
--   <a>Widget:marginStart</a> property.
--   
--   <i>Since: 3.12</i>
widgetSetMarginStart :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ()

-- | Sets the top margin of <i><tt>widget</tt></i>. See the
--   <a>Widget:marginTop</a> property.
--   
--   <i>Since: 3.0</i>
widgetSetMarginTop :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ()

-- | Widgets can be named, which allows you to refer to them from a CSS
--   file. You can apply a style to widgets with a particular name in the
--   CSS file. See the documentation for the CSS syntax (on the same page
--   as the docs for <a>StyleContext</a>).
--   
--   Note that the CSS syntax has certain special characters to delimit and
--   represent elements in a selector (period, #, &gt;, *...), so using
--   these will make your widget impossible to match by name. Any
--   combination of alphanumeric symbols, dashes and underscores will
--   suffice.
widgetSetName :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> m ()

-- | Sets the <a>Widget:noShowAll</a> property, which determines whether
--   calls to <a>widgetShowAll</a> will affect this widget.
--   
--   This is mostly for use in constructing widget hierarchies with
--   externally controlled visibility, see <a>UIManager</a>.
--   
--   <i>Since: 2.4</i>
widgetSetNoShowAll :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Request the <i><tt>widget</tt></i> to be rendered partially
--   transparent, with opacity 0 being fully transparent and 1 fully
--   opaque. (Opacity values are clamped to the [0,1] range.). This works
--   on both toplevel widget, and child widgets, although there are some
--   limitations:
--   
--   For toplevel widgets this depends on the capabilities of the windowing
--   system. On X11 this has any effect only on X screens with a
--   compositing manager running. See <a>widgetIsComposited</a>. On Windows
--   it should work always, although setting a window’s opacity after the
--   window has been shown causes it to flicker once on Windows.
--   
--   For child widgets it doesn’t work if any affected widget has a native
--   window, or disables double buffering.
--   
--   <i>Since: 3.8</i>
widgetSetOpacity :: (HasCallStack, MonadIO m, IsWidget a) => a -> Double -> m ()

-- | This function is useful only when implementing subclasses of
--   <a>Container</a>. Sets the container as the parent of
--   <i><tt>widget</tt></i>, and takes care of some details such as
--   updating the state and style of the child to reflect its new location.
--   The opposite function is <a>widgetUnparent</a>.
widgetSetParent :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m ()

-- | Sets a non default parent window for <i><tt>widget</tt></i>.
--   
--   For <a>Window</a> classes, setting a <i><tt>parentWindow</tt></i>
--   effects whether the window is a toplevel window or can be embedded
--   into other widgets.
--   
--   For <a>Window</a> classes, this needs to be called before the window
--   is realized.
widgetSetParentWindow :: (HasCallStack, MonadIO m, IsWidget a, IsWindow b) => a -> b -> m ()

-- | Marks the widget as being realized. This function must only be called
--   after all <tt><i>GdkWindows</i></tt> for the <i><tt>widget</tt></i>
--   have been created and registered.
--   
--   This function should only ever be called in a derived widget's
--   “realize” or “unrealize” implementation.
--   
--   <i>Since: 2.20</i>
widgetSetRealized :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets whether the entire widget is queued for drawing when its size
--   allocation changes. By default, this setting is <a>True</a> and the
--   entire widget is redrawn on every size change. If your widget leaves
--   the upper left unchanged when made bigger, turning this setting off
--   will improve performance.
--   
--   Note that for widgets where <a>widgetGetHasWindow</a> is <a>False</a>
--   setting this flag to <a>False</a> turns off all allocation on
--   resizing: the widget will not even redraw if its position changes;
--   this is to allow containers that don’t draw anything to avoid excess
--   invalidations. If you set this flag on a widget with no window that
--   does draw on <i><tt>widget</tt></i>-&gt;window, you are responsible
--   for invalidating both the old and new allocation of the widget when
--   the widget is moved and responsible for invalidating regions newly
--   when the widget increases size.
widgetSetRedrawOnAllocate :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the sensitivity of a widget. A widget is sensitive if the user
--   can interact with it. Insensitive widgets are “grayed out” and the
--   user can’t interact with them. Insensitive widgets are known as
--   “inactive”, “disabled”, or “ghosted” in some other toolkits.
widgetSetSensitive :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | This function is for use in widget implementations. Sets the state of
--   a widget (insensitive, prelighted, etc.) Usually you should set the
--   state using wrapper functions such as <a>widgetSetSensitive</a>.
widgetSetState :: (HasCallStack, MonadIO m, IsWidget a) => a -> StateType -> m ()

-- | This function is for use in widget implementations. Turns on flag
--   values in the current widget state (insensitive, prelighted, etc.).
--   
--   This function accepts the values <a>StateFlagsDirLtr</a> and
--   <a>StateFlagsDirRtl</a> but ignores them. If you want to set the
--   widget's direction, use <a>widgetSetDirection</a>.
--   
--   It is worth mentioning that any other state than
--   <a>StateFlagsInsensitive</a>, will be propagated down to all
--   non-internal children if <i><tt>widget</tt></i> is a <a>Container</a>,
--   while <a>StateFlagsInsensitive</a> itself will be propagated down to
--   all <a>Container</a> children by different means than turning on the
--   state flag down the hierarchy, both <a>widgetGetStateFlags</a> and
--   <a>widgetIsSensitive</a> will make use of these.
--   
--   <i>Since: 3.0</i>
widgetSetStateFlags :: (HasCallStack, MonadIO m, IsWidget a) => a -> [StateFlags] -> Bool -> m ()

-- | Enables or disables multiple pointer awareness. If this setting is
--   <a>True</a>, <i><tt>widget</tt></i> will start receiving multiple, per
--   device enter/leave events. Note that if custom
--   <tt><i>GdkWindows</i></tt> are created in <a>Widget::realize</a>,
--   <a>windowSetSupportMultidevice</a> will have to be called manually on
--   them.
--   
--   <i>Since: 3.0</i>
widgetSetSupportMultidevice :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Replaces the default window used for displaying tooltips with
--   <i><tt>customWindow</tt></i>. GTK+ will take care of showing and
--   hiding <i><tt>customWindow</tt></i> at the right moment, to behave
--   likewise as the default tooltip window. If
--   <i><tt>customWindow</tt></i> is <a>Nothing</a>, the default tooltip
--   window will be used.
--   
--   <i>Since: 2.12</i>
widgetSetTooltipWindow :: (HasCallStack, MonadIO m, IsWidget a, IsWindow b) => a -> Maybe b -> m ()

-- | Sets the vertical alignment of <i><tt>widget</tt></i>. See the
--   <a>Widget:valign</a> property.
widgetSetValign :: (HasCallStack, MonadIO m, IsWidget a) => a -> Align -> m ()

-- | Sets whether the widget would like any available extra vertical space.
--   
--   See <a>widgetSetHexpand</a> for more detail.
widgetSetVexpand :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets whether the vexpand flag (see <a>widgetGetVexpand</a>) will be
--   used.
--   
--   See <a>widgetSetHexpandSet</a> for more detail.
widgetSetVexpandSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the visibility state of <i><tt>widget</tt></i>. Note that setting
--   this to <a>True</a> doesn’t mean the widget is actually viewable, see
--   <a>widgetGetVisible</a>.
--   
--   This function simply calls <a>widgetShow</a> or <a>widgetHide</a> but
--   is nicer to use when the visibility of the widget depends on some
--   condition.
--   
--   <i>Since: 2.18</i>
widgetSetVisible :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the visual that should be used for by widget and its children for
--   creating <tt><i>GdkWindows</i></tt>. The visual must be on the same
--   <a>Screen</a> as returned by <a>widgetGetScreen</a>, so handling the
--   <a>Widget::screenChanged</a> signal is necessary.
--   
--   Setting a new <i><tt>visual</tt></i> will not cause
--   <i><tt>widget</tt></i> to recreate its windows, so you should call
--   this function before <i><tt>widget</tt></i> is realized.
widgetSetVisual :: (HasCallStack, MonadIO m, IsWidget a, IsVisual b) => a -> Maybe b -> m ()

-- | Sets a widget’s window. This function should only be used in a
--   widget’s <a>Widget::realize</a> implementation. The
--   <tt><i>window</i></tt> passed is usually either new window created
--   with <a>windowNew</a>, or the window of its parent widget as returned
--   by <a>widgetGetParentWindow</a>.
--   
--   Widgets must indicate whether they will create their own <a>Window</a>
--   by calling <a>widgetSetHasWindow</a>. This is usually done in the
--   widget’s <tt><i>init()</i></tt> function.
--   
--   Note that this function does not add any reference to
--   <i><tt>window</tt></i>.
--   
--   <i>Since: 2.18</i>
widgetSetWindow :: (HasCallStack, MonadIO m, IsWidget a, IsWindow b) => a -> b -> m ()

-- | Sets a shape for this widget’s GDK window. This allows for transparent
--   windows etc., see <a>windowShapeCombineRegion</a> for more
--   information.
--   
--   <i>Since: 3.0</i>
widgetShapeCombineRegion :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Region -> m ()

-- | Shows a widget. If the widget is an unmapped toplevel widget (i.e. a
--   <a>Window</a> that has not yet been shown), enter the main loop and
--   wait for the window to actually be mapped. Be careful; because the
--   main loop is running, anything can happen during this function.
widgetShowNow :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | This function is only used by <a>Container</a> subclasses, to assign a
--   size and position to their child widgets.
--   
--   In this function, the allocation may be adjusted. It will be forced to
--   a 1x1 minimum size, and the adjust_size_allocation virtual method on
--   the child will be used to adjust the allocation. Standard adjustments
--   include removing the widget’s margins, and applying the widget’s
--   <a>Widget:halign</a> and <a>Widget:valign</a> properties.
--   
--   For baseline support in containers you need to use
--   <a>widgetSizeAllocateWithBaseline</a> instead.
widgetSizeAllocate :: (HasCallStack, MonadIO m, IsWidget a) => a -> Rectangle -> m ()

-- | This function is only used by <a>Container</a> subclasses, to assign a
--   size, position and (optionally) baseline to their child widgets.
--   
--   In this function, the allocation and baseline may be adjusted. It will
--   be forced to a 1x1 minimum size, and the adjust_size_allocation
--   virtual and adjust_baseline_allocation methods on the child will be
--   used to adjust the allocation and baseline. Standard adjustments
--   include removing the widget's margins, and applying the widget’s
--   <a>Widget:halign</a> and <a>Widget:valign</a> properties.
--   
--   If the child widget does not have a valign of <a>AlignBaseline</a> the
--   baseline argument is ignored and -1 is used instead.
--   
--   <i>Since: 3.10</i>
widgetSizeAllocateWithBaseline :: (HasCallStack, MonadIO m, IsWidget a) => a -> Rectangle -> Int32 -> m ()

-- | This function is typically used when implementing a <a>Container</a>
--   subclass. Obtains the preferred size of a widget. The container uses
--   this information to arrange its child widgets and decide what size
--   allocations to give them with <a>widgetSizeAllocate</a>.
--   
--   You can also call this function from an application, with some
--   caveats. Most notably, getting a size request requires the widget to
--   be associated with a screen, because font information may be needed.
--   Multihead-aware applications should keep this in mind.
--   
--   Also remember that the size request is not necessarily the size a
--   widget will actually be allocated.
widgetSizeRequest :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Requisition

-- | This function attaches the widget’s <a>Style</a> to the widget's
--   <a>Window</a>. It is a replacement for
--   
--   <pre>
--   widget-&gt;style = gtk_style_attach (widget-&gt;style, widget-&gt;window);
--   </pre>
--   
--   and should only ever be called in a derived widget’s “realize”
--   implementation which does not chain up to its parent class' “realize”
--   implementation, because one of the parent classes (finally
--   <a>Widget</a>) would attach the style itself.
--   
--   <i>Since: 2.20</i>
widgetStyleAttach :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Gets the value of a style property of <i><tt>widget</tt></i>.
widgetStyleGetProperty :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> GValue -> m ()

-- | Reverts the effect of a previous call to
--   <a>widgetFreezeChildNotify</a>. This causes all queued
--   <a>Widget::childNotify</a> signals on <i><tt>widget</tt></i> to be
--   emitted.
widgetThawChildNotify :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Translate coordinates relative to <i><tt>srcWidget</tt></i>’s
--   allocation to coordinates relative to <i><tt>destWidget</tt></i>’s
--   allocations. In order to perform this operation, both widgets must be
--   realized, and must share a common toplevel.
widgetTranslateCoordinates :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> Int32 -> Int32 -> m (Bool, Int32, Int32)

-- | Triggers a tooltip query on the display where the toplevel of
--   <i><tt>widget</tt></i> is located. See
--   <a>tooltipTriggerTooltipQuery</a> for more information.
--   
--   <i>Since: 2.12</i>
widgetTriggerTooltipQuery :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | This function is only for use in widget implementations. Causes a
--   widget to be unmapped if it’s currently mapped.
widgetUnmap :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | This function is only for use in widget implementations. Should be
--   called by implementations of the remove method on <a>Container</a>, to
--   dissociate a child from the container.
widgetUnparent :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | This function is only useful in widget implementations. Causes a
--   widget to be unrealized (frees all GDK resources associated with the
--   widget, such as <i><tt>widget</tt></i>-&gt;window).
widgetUnrealize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Unregisters a <a>Window</a> from the widget that was previously set up
--   with <a>widgetRegisterWindow</a>. You need to call this when the
--   window is no longer used by the widget, such as when you destroy it.
--   
--   <i>Since: 3.8</i>
widgetUnregisterWindow :: (HasCallStack, MonadIO m, IsWidget a, IsWindow b) => a -> b -> m ()

-- | This function is for use in widget implementations. Turns off flag
--   values for the current widget state (insensitive, prelighted, etc.).
--   See <a>widgetSetStateFlags</a>.
--   
--   <i>Since: 3.0</i>
widgetUnsetStateFlags :: (HasCallStack, MonadIO m, IsWidget a) => a -> [StateFlags] -> m ()

-- | Returns the default style used by all widgets initially.
widgetGetDefaultStyle :: (HasCallStack, MonadIO m) => m Style

-- | Cancels the effect of a previous call to
--   <a>widgetPushCompositeChild</a>.
widgetPopCompositeChild :: (HasCallStack, MonadIO m) => m ()

-- | Makes all newly-created widgets as composite children until the
--   corresponding <a>widgetPopCompositeChild</a> call.
--   
--   A composite child is a child that’s an implementation detail of the
--   container it’s inside and should not be visible to people using the
--   container. Composite children aren’t treated differently by GTK+ (but
--   see <a>containerForeach</a> vs. <a>containerForall</a>), but e.g. GUI
--   builders might want to treat them in a different way.
widgetPushCompositeChild :: (HasCallStack, MonadIO m) => m ()

-- | Sets the default reading direction for widgets where the direction has
--   not been explicitly set by <a>widgetSetDirection</a>.
widgetSetDefaultDirection :: (HasCallStack, MonadIO m) => TextDirection -> m ()

-- | Replaces the widget packed into the tooltip with
--   <i><tt>customWidget</tt></i>. <i><tt>customWidget</tt></i> does not
--   get destroyed when the tooltip goes away. By default a box with a
--   <a>Image</a> and <a>Label</a> is embedded in the tooltip, which can be
--   configured using <a>tooltipSetMarkup</a> and <a>tooltipSetIcon</a>.
--   
--   <i>Since: 2.12</i>
tooltipSetCustom :: (HasCallStack, MonadIO m, IsTooltip a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the icon of the tooltip (which is in front of the text) to be
--   <i><tt>pixbuf</tt></i>. If <i><tt>pixbuf</tt></i> is <a>Nothing</a>,
--   the image will be hidden.
--   
--   <i>Since: 2.12</i>
tooltipSetIcon :: (HasCallStack, MonadIO m, IsTooltip a, IsPixbuf b) => a -> Maybe b -> m ()

-- | Sets the icon of the tooltip (which is in front of the text) to be the
--   icon indicated by <i><tt>gicon</tt></i> with the size indicated by
--   <i><tt>size</tt></i>. If <i><tt>gicon</tt></i> is <a>Nothing</a>, the
--   image will be hidden.
--   
--   <i>Since: 2.20</i>
tooltipSetIconFromGicon :: (HasCallStack, MonadIO m, IsTooltip a, IsIcon b) => a -> Maybe b -> Int32 -> m ()

-- | Sets the icon of the tooltip (which is in front of the text) to be the
--   icon indicated by <i><tt>iconName</tt></i> with the size indicated by
--   <i><tt>size</tt></i>. If <i><tt>iconName</tt></i> is <a>Nothing</a>,
--   the image will be hidden.
--   
--   <i>Since: 2.14</i>
tooltipSetIconFromIconName :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe Text -> Int32 -> m ()

-- | Sets the icon of the tooltip (which is in front of the text) to be the
--   stock item indicated by <i><tt>stockId</tt></i> with the size
--   indicated by <i><tt>size</tt></i>. If <i><tt>stockId</tt></i> is
--   <a>Nothing</a>, the image will be hidden.
--   
--   <i>Since: 2.12</i>
tooltipSetIconFromStock :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe Text -> Int32 -> m ()

-- | Connect a signal handler for the <a>tagAdded</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textTagTable #tagAdded callback
--   </pre>
onTextTagTableTagAdded :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>tagAdded</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textTagTable #tagAdded callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextTagTableTagAdded :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>tagChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textTagTable #tagChanged callback
--   </pre>
onTextTagTableTagChanged :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>tagChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textTagTable #tagChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextTagTableTagChanged :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>tagRemoved</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textTagTable #tagRemoved callback
--   </pre>
onTextTagTableTagRemoved :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagRemovedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>tagRemoved</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textTagTable #tagRemoved callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextTagTableTagRemoved :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagRemovedCallback) -> m SignalHandlerId

-- | Creates a new <a>TextTagTable</a>. The table contains no tags by
--   default.
textTagTableNew :: (HasCallStack, MonadIO m) => m TextTagTable

-- | Add a tag to the table. The tag is assigned the highest priority in
--   the table.
--   
--   <i><tt>tag</tt></i> must not be in a tag table already, and may not
--   have the same name as an already-added tag.
textTagTableAdd :: (HasCallStack, MonadIO m, IsTextTagTable a, IsTextTag b) => a -> b -> m Bool

-- | Remove a tag from the table. If a <a>TextBuffer</a> has
--   <i><tt>table</tt></i> as its tag table, the tag is removed from the
--   buffer. The table’s reference to the tag is removed, so the tag will
--   end up destroyed if you don’t have a reference to it.
textTagTableRemove :: (HasCallStack, MonadIO m, IsTextTagTable a, IsTextTag b) => a -> b -> m ()

-- | Connect a signal handler for the <a>event</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> textTag #event callback
--   </pre>
onTextTagEvent :: (IsTextTag a, MonadIO m) => a -> ((?self :: a) => TextTagEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>event</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textTag #event callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextTagEvent :: (IsTextTag a, MonadIO m) => a -> ((?self :: a) => TextTagEventCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>accumulative-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #accumulativeMargin
--   </pre>
getTextTagAccumulativeMargin :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>accumulative-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #accumulativeMargin <a>:=</a> value ]
--   </pre>
setTextTagAccumulativeMargin :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accumulative-margin</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagAccumulativeMargin :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Set the value of the “<tt>background</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #background <a>:=</a> value ]
--   </pre>
setTextTagBackground :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagBackground :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>background</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #background
--   </pre>
clearTextTagBackground :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>background-full-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #backgroundFullHeight
--   </pre>
getTextTagBackgroundFullHeight :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>background-full-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #backgroundFullHeight <a>:=</a> value ]
--   </pre>
setTextTagBackgroundFullHeight :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-full-height</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagBackgroundFullHeight :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>background-full-height-set</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #backgroundFullHeightSet
--   </pre>
getTextTagBackgroundFullHeightSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>background-full-height-set</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #backgroundFullHeightSet <a>:=</a> value ]
--   </pre>
setTextTagBackgroundFullHeightSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-full-height-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagBackgroundFullHeightSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>background-gdk</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #backgroundGdk
--   </pre>
getTextTagBackgroundGdk :: (MonadIO m, IsTextTag o) => o -> m (Maybe Color)

-- | Set the value of the “<tt>background-gdk</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #backgroundGdk <a>:=</a> value ]
--   </pre>
setTextTagBackgroundGdk :: (MonadIO m, IsTextTag o) => o -> Color -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-gdk</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagBackgroundGdk :: (IsTextTag o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Set the value of the “<tt>background-gdk</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #backgroundGdk
--   </pre>
clearTextTagBackgroundGdk :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>background-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #backgroundRgba
--   </pre>
getTextTagBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>background-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #backgroundRgba <a>:=</a> value ]
--   </pre>
setTextTagBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-rgba</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagBackgroundRgba :: (IsTextTag o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “<tt>background-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #backgroundRgba
--   </pre>
clearTextTagBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>background-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #backgroundSet
--   </pre>
getTextTagBackgroundSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>background-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #backgroundSet <a>:=</a> value ]
--   </pre>
setTextTagBackgroundSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagBackgroundSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #direction
--   </pre>
getTextTagDirection :: (MonadIO m, IsTextTag o) => o -> m TextDirection

-- | Set the value of the “<tt>direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #direction <a>:=</a> value ]
--   </pre>
setTextTagDirection :: (MonadIO m, IsTextTag o) => o -> TextDirection -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>direction</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagDirection :: (IsTextTag o, MonadIO m) => TextDirection -> m (GValueConstruct o)

-- | Get the value of the “<tt>editable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #editable
--   </pre>
getTextTagEditable :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>editable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #editable <a>:=</a> value ]
--   </pre>
setTextTagEditable :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>editable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagEditable :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>editable-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #editableSet
--   </pre>
getTextTagEditableSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>editable-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #editableSet <a>:=</a> value ]
--   </pre>
setTextTagEditableSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>editable-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagEditableSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>fallback</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #fallback
--   </pre>
getTextTagFallback :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>fallback</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #fallback <a>:=</a> value ]
--   </pre>
setTextTagFallback :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fallback</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagFallback :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>fallback-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #fallbackSet
--   </pre>
getTextTagFallbackSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>fallback-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #fallbackSet <a>:=</a> value ]
--   </pre>
setTextTagFallbackSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fallback-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagFallbackSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>family</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #family
--   </pre>
getTextTagFamily :: (MonadIO m, IsTextTag o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>family</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #family <a>:=</a> value ]
--   </pre>
setTextTagFamily :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>family</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagFamily :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>family</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #family
--   </pre>
clearTextTagFamily :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>family-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #familySet
--   </pre>
getTextTagFamilySet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>family-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #familySet <a>:=</a> value ]
--   </pre>
setTextTagFamilySet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>family-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagFamilySet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>font</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #font
--   </pre>
getTextTagFont :: (MonadIO m, IsTextTag o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>font</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #font <a>:=</a> value ]
--   </pre>
setTextTagFont :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagFont :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>font</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #font
--   </pre>
clearTextTagFont :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>font-desc</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #fontDesc
--   </pre>
getTextTagFontDesc :: (MonadIO m, IsTextTag o) => o -> m (Maybe FontDescription)

-- | Set the value of the “<tt>font-desc</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #fontDesc <a>:=</a> value ]
--   </pre>
setTextTagFontDesc :: (MonadIO m, IsTextTag o) => o -> FontDescription -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font-desc</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagFontDesc :: (IsTextTag o, MonadIO m) => FontDescription -> m (GValueConstruct o)

-- | Set the value of the “<tt>font-desc</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #fontDesc
--   </pre>
clearTextTagFontDesc :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>font-features</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #fontFeatures
--   </pre>
getTextTagFontFeatures :: (MonadIO m, IsTextTag o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>font-features</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #fontFeatures <a>:=</a> value ]
--   </pre>
setTextTagFontFeatures :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font-features</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagFontFeatures :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>font-features</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #fontFeatures
--   </pre>
clearTextTagFontFeatures :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>font-features-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #fontFeaturesSet
--   </pre>
getTextTagFontFeaturesSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>font-features-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #fontFeaturesSet <a>:=</a> value ]
--   </pre>
setTextTagFontFeaturesSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font-features-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagFontFeaturesSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Set the value of the “<tt>foreground</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #foreground <a>:=</a> value ]
--   </pre>
setTextTagForeground :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>foreground</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagForeground :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>foreground</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #foreground
--   </pre>
clearTextTagForeground :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>foreground-gdk</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #foregroundGdk
--   </pre>
getTextTagForegroundGdk :: (MonadIO m, IsTextTag o) => o -> m (Maybe Color)

-- | Set the value of the “<tt>foreground-gdk</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #foregroundGdk <a>:=</a> value ]
--   </pre>
setTextTagForegroundGdk :: (MonadIO m, IsTextTag o) => o -> Color -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>foreground-gdk</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagForegroundGdk :: (IsTextTag o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Set the value of the “<tt>foreground-gdk</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #foregroundGdk
--   </pre>
clearTextTagForegroundGdk :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>foreground-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #foregroundRgba
--   </pre>
getTextTagForegroundRgba :: (MonadIO m, IsTextTag o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>foreground-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #foregroundRgba <a>:=</a> value ]
--   </pre>
setTextTagForegroundRgba :: (MonadIO m, IsTextTag o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>foreground-rgba</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagForegroundRgba :: (IsTextTag o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “<tt>foreground-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #foregroundRgba
--   </pre>
clearTextTagForegroundRgba :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>foreground-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #foregroundSet
--   </pre>
getTextTagForegroundSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>foreground-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #foregroundSet <a>:=</a> value ]
--   </pre>
setTextTagForegroundSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>foreground-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagForegroundSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>indent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #indent
--   </pre>
getTextTagIndent :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>indent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #indent <a>:=</a> value ]
--   </pre>
setTextTagIndent :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>indent</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagIndent :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>indent-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #indentSet
--   </pre>
getTextTagIndentSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>indent-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #indentSet <a>:=</a> value ]
--   </pre>
setTextTagIndentSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>indent-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagIndentSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>invisible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #invisible
--   </pre>
getTextTagInvisible :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>invisible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #invisible <a>:=</a> value ]
--   </pre>
setTextTagInvisible :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>invisible</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagInvisible :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>invisible-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #invisibleSet
--   </pre>
getTextTagInvisibleSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>invisible-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #invisibleSet <a>:=</a> value ]
--   </pre>
setTextTagInvisibleSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>invisible-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagInvisibleSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>justification</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #justification
--   </pre>
getTextTagJustification :: (MonadIO m, IsTextTag o) => o -> m Justification

-- | Set the value of the “<tt>justification</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #justification <a>:=</a> value ]
--   </pre>
setTextTagJustification :: (MonadIO m, IsTextTag o) => o -> Justification -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>justification</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagJustification :: (IsTextTag o, MonadIO m) => Justification -> m (GValueConstruct o)

-- | Get the value of the “<tt>justification-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #justificationSet
--   </pre>
getTextTagJustificationSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>justification-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #justificationSet <a>:=</a> value ]
--   </pre>
setTextTagJustificationSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>justification-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagJustificationSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>language</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #language
--   </pre>
getTextTagLanguage :: (MonadIO m, IsTextTag o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>language</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #language <a>:=</a> value ]
--   </pre>
setTextTagLanguage :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>language</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagLanguage :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>language</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #language
--   </pre>
clearTextTagLanguage :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>language-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #languageSet
--   </pre>
getTextTagLanguageSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>language-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #languageSet <a>:=</a> value ]
--   </pre>
setTextTagLanguageSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>language-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagLanguageSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>left-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #leftMargin
--   </pre>
getTextTagLeftMargin :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>left-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #leftMargin <a>:=</a> value ]
--   </pre>
setTextTagLeftMargin :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>left-margin</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagLeftMargin :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>left-margin-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #leftMarginSet
--   </pre>
getTextTagLeftMarginSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>left-margin-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #leftMarginSet <a>:=</a> value ]
--   </pre>
setTextTagLeftMarginSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>left-margin-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagLeftMarginSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>letter-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #letterSpacing
--   </pre>
getTextTagLetterSpacing :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>letter-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #letterSpacing <a>:=</a> value ]
--   </pre>
setTextTagLetterSpacing :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>letter-spacing</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagLetterSpacing :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>letter-spacing-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #letterSpacingSet
--   </pre>
getTextTagLetterSpacingSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>letter-spacing-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #letterSpacingSet <a>:=</a> value ]
--   </pre>
setTextTagLetterSpacingSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>letter-spacing-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagLetterSpacingSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #name
--   </pre>
getTextTagName :: (MonadIO m, IsTextTag o) => o -> m (Maybe Text)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>name</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagName :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>paragraph-background</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #paragraphBackground <a>:=</a> value ]
--   </pre>
setTextTagParagraphBackground :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>paragraph-background</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagParagraphBackground :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>paragraph-background</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #paragraphBackground
--   </pre>
clearTextTagParagraphBackground :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>paragraph-background-gdk</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #paragraphBackgroundGdk
--   </pre>
getTextTagParagraphBackgroundGdk :: (MonadIO m, IsTextTag o) => o -> m (Maybe Color)

-- | Set the value of the “<tt>paragraph-background-gdk</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #paragraphBackgroundGdk <a>:=</a> value ]
--   </pre>
setTextTagParagraphBackgroundGdk :: (MonadIO m, IsTextTag o) => o -> Color -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>paragraph-background-gdk</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagParagraphBackgroundGdk :: (IsTextTag o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Set the value of the “<tt>paragraph-background-gdk</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #paragraphBackgroundGdk
--   </pre>
clearTextTagParagraphBackgroundGdk :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>paragraph-background-rgba</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #paragraphBackgroundRgba
--   </pre>
getTextTagParagraphBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>paragraph-background-rgba</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #paragraphBackgroundRgba <a>:=</a> value ]
--   </pre>
setTextTagParagraphBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>paragraph-background-rgba</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagParagraphBackgroundRgba :: (IsTextTag o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “<tt>paragraph-background-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #paragraphBackgroundRgba
--   </pre>
clearTextTagParagraphBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>paragraph-background-set</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #paragraphBackgroundSet
--   </pre>
getTextTagParagraphBackgroundSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>paragraph-background-set</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #paragraphBackgroundSet <a>:=</a> value ]
--   </pre>
setTextTagParagraphBackgroundSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>paragraph-background-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagParagraphBackgroundSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-above-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #pixelsAboveLines
--   </pre>
getTextTagPixelsAboveLines :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>pixels-above-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #pixelsAboveLines <a>:=</a> value ]
--   </pre>
setTextTagPixelsAboveLines :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-above-lines</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagPixelsAboveLines :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-above-lines-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #pixelsAboveLinesSet
--   </pre>
getTextTagPixelsAboveLinesSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>pixels-above-lines-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #pixelsAboveLinesSet <a>:=</a> value ]
--   </pre>
setTextTagPixelsAboveLinesSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-above-lines-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagPixelsAboveLinesSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-below-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #pixelsBelowLines
--   </pre>
getTextTagPixelsBelowLines :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>pixels-below-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #pixelsBelowLines <a>:=</a> value ]
--   </pre>
setTextTagPixelsBelowLines :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-below-lines</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagPixelsBelowLines :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-below-lines-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #pixelsBelowLinesSet
--   </pre>
getTextTagPixelsBelowLinesSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>pixels-below-lines-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #pixelsBelowLinesSet <a>:=</a> value ]
--   </pre>
setTextTagPixelsBelowLinesSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-below-lines-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagPixelsBelowLinesSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-inside-wrap</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #pixelsInsideWrap
--   </pre>
getTextTagPixelsInsideWrap :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>pixels-inside-wrap</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #pixelsInsideWrap <a>:=</a> value ]
--   </pre>
setTextTagPixelsInsideWrap :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-inside-wrap</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagPixelsInsideWrap :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-inside-wrap-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #pixelsInsideWrapSet
--   </pre>
getTextTagPixelsInsideWrapSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>pixels-inside-wrap-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #pixelsInsideWrapSet <a>:=</a> value ]
--   </pre>
setTextTagPixelsInsideWrapSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-inside-wrap-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagPixelsInsideWrapSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>right-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #rightMargin
--   </pre>
getTextTagRightMargin :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>right-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #rightMargin <a>:=</a> value ]
--   </pre>
setTextTagRightMargin :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>right-margin</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagRightMargin :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>right-margin-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #rightMarginSet
--   </pre>
getTextTagRightMarginSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>right-margin-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #rightMarginSet <a>:=</a> value ]
--   </pre>
setTextTagRightMarginSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>right-margin-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagRightMarginSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>rise</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #rise
--   </pre>
getTextTagRise :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>rise</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #rise <a>:=</a> value ]
--   </pre>
setTextTagRise :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rise</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagRise :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>rise-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #riseSet
--   </pre>
getTextTagRiseSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>rise-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #riseSet <a>:=</a> value ]
--   </pre>
setTextTagRiseSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rise-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagRiseSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>scale</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #scale
--   </pre>
getTextTagScale :: (MonadIO m, IsTextTag o) => o -> m Double

-- | Set the value of the “<tt>scale</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #scale <a>:=</a> value ]
--   </pre>
setTextTagScale :: (MonadIO m, IsTextTag o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>scale</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagScale :: (IsTextTag o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>scale-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #scaleSet
--   </pre>
getTextTagScaleSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>scale-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #scaleSet <a>:=</a> value ]
--   </pre>
setTextTagScaleSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>scale-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagScaleSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #size
--   </pre>
getTextTagSize :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #size <a>:=</a> value ]
--   </pre>
setTextTagSize :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagSize :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>size-points</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #sizePoints
--   </pre>
getTextTagSizePoints :: (MonadIO m, IsTextTag o) => o -> m Double

-- | Set the value of the “<tt>size-points</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #sizePoints <a>:=</a> value ]
--   </pre>
setTextTagSizePoints :: (MonadIO m, IsTextTag o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size-points</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagSizePoints :: (IsTextTag o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>size-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #sizeSet
--   </pre>
getTextTagSizeSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>size-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #sizeSet <a>:=</a> value ]
--   </pre>
setTextTagSizeSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagSizeSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>stretch</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #stretch
--   </pre>
getTextTagStretch :: (MonadIO m, IsTextTag o) => o -> m Stretch

-- | Set the value of the “<tt>stretch</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #stretch <a>:=</a> value ]
--   </pre>
setTextTagStretch :: (MonadIO m, IsTextTag o) => o -> Stretch -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stretch</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagStretch :: (IsTextTag o, MonadIO m) => Stretch -> m (GValueConstruct o)

-- | Get the value of the “<tt>stretch-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #stretchSet
--   </pre>
getTextTagStretchSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>stretch-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #stretchSet <a>:=</a> value ]
--   </pre>
setTextTagStretchSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stretch-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagStretchSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>strikethrough</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #strikethrough
--   </pre>
getTextTagStrikethrough :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>strikethrough</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #strikethrough <a>:=</a> value ]
--   </pre>
setTextTagStrikethrough :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>strikethrough</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagStrikethrough :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>strikethrough-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #strikethroughRgba
--   </pre>
getTextTagStrikethroughRgba :: (MonadIO m, IsTextTag o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>strikethrough-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #strikethroughRgba <a>:=</a> value ]
--   </pre>
setTextTagStrikethroughRgba :: (MonadIO m, IsTextTag o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>strikethrough-rgba</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagStrikethroughRgba :: (IsTextTag o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “<tt>strikethrough-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #strikethroughRgba
--   </pre>
clearTextTagStrikethroughRgba :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>strikethrough-rgba-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #strikethroughRgbaSet
--   </pre>
getTextTagStrikethroughRgbaSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>strikethrough-rgba-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #strikethroughRgbaSet <a>:=</a> value ]
--   </pre>
setTextTagStrikethroughRgbaSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>strikethrough-rgba-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagStrikethroughRgbaSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>strikethrough-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #strikethroughSet
--   </pre>
getTextTagStrikethroughSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>strikethrough-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #strikethroughSet <a>:=</a> value ]
--   </pre>
setTextTagStrikethroughSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>strikethrough-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagStrikethroughSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #style
--   </pre>
getTextTagStyle :: (MonadIO m, IsTextTag o) => o -> m Style

-- | Set the value of the “<tt>style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #style <a>:=</a> value ]
--   </pre>
setTextTagStyle :: (MonadIO m, IsTextTag o) => o -> Style -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>style</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagStyle :: (IsTextTag o, MonadIO m) => Style -> m (GValueConstruct o)

-- | Get the value of the “<tt>style-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #styleSet
--   </pre>
getTextTagStyleSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>style-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #styleSet <a>:=</a> value ]
--   </pre>
setTextTagStyleSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>style-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagStyleSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>tabs</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #tabs
--   </pre>
getTextTagTabs :: (MonadIO m, IsTextTag o) => o -> m (Maybe TabArray)

-- | Set the value of the “<tt>tabs</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #tabs <a>:=</a> value ]
--   </pre>
setTextTagTabs :: (MonadIO m, IsTextTag o) => o -> TabArray -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tabs</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagTabs :: (IsTextTag o, MonadIO m) => TabArray -> m (GValueConstruct o)

-- | Set the value of the “<tt>tabs</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #tabs
--   </pre>
clearTextTagTabs :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>tabs-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #tabsSet
--   </pre>
getTextTagTabsSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>tabs-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #tabsSet <a>:=</a> value ]
--   </pre>
setTextTagTabsSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tabs-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagTabsSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #underline
--   </pre>
getTextTagUnderline :: (MonadIO m, IsTextTag o) => o -> m Underline

-- | Set the value of the “<tt>underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #underline <a>:=</a> value ]
--   </pre>
setTextTagUnderline :: (MonadIO m, IsTextTag o) => o -> Underline -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>underline</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagUnderline :: (IsTextTag o, MonadIO m) => Underline -> m (GValueConstruct o)

-- | Get the value of the “<tt>underline-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #underlineRgba
--   </pre>
getTextTagUnderlineRgba :: (MonadIO m, IsTextTag o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>underline-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #underlineRgba <a>:=</a> value ]
--   </pre>
setTextTagUnderlineRgba :: (MonadIO m, IsTextTag o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>underline-rgba</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagUnderlineRgba :: (IsTextTag o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “<tt>underline-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #underlineRgba
--   </pre>
clearTextTagUnderlineRgba :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Get the value of the “<tt>underline-rgba-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #underlineRgbaSet
--   </pre>
getTextTagUnderlineRgbaSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>underline-rgba-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #underlineRgbaSet <a>:=</a> value ]
--   </pre>
setTextTagUnderlineRgbaSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>underline-rgba-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagUnderlineRgbaSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>underline-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #underlineSet
--   </pre>
getTextTagUnderlineSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>underline-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #underlineSet <a>:=</a> value ]
--   </pre>
setTextTagUnderlineSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>underline-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagUnderlineSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>variant</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #variant
--   </pre>
getTextTagVariant :: (MonadIO m, IsTextTag o) => o -> m Variant

-- | Set the value of the “<tt>variant</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #variant <a>:=</a> value ]
--   </pre>
setTextTagVariant :: (MonadIO m, IsTextTag o) => o -> Variant -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>variant</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagVariant :: (IsTextTag o, MonadIO m) => Variant -> m (GValueConstruct o)

-- | Get the value of the “<tt>variant-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #variantSet
--   </pre>
getTextTagVariantSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>variant-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #variantSet <a>:=</a> value ]
--   </pre>
setTextTagVariantSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>variant-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagVariantSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>weight</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #weight
--   </pre>
getTextTagWeight :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>weight</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #weight <a>:=</a> value ]
--   </pre>
setTextTagWeight :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>weight</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagWeight :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>weight-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #weightSet
--   </pre>
getTextTagWeightSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>weight-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #weightSet <a>:=</a> value ]
--   </pre>
setTextTagWeightSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>weight-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagWeightSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #wrapMode
--   </pre>
getTextTagWrapMode :: (MonadIO m, IsTextTag o) => o -> m WrapMode

-- | Set the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #wrapMode <a>:=</a> value ]
--   </pre>
setTextTagWrapMode :: (MonadIO m, IsTextTag o) => o -> WrapMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap-mode</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagWrapMode :: (IsTextTag o, MonadIO m) => WrapMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap-mode-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #wrapModeSet
--   </pre>
getTextTagWrapModeSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>wrap-mode-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #wrapModeSet <a>:=</a> value ]
--   </pre>
setTextTagWrapModeSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap-mode-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagWrapModeSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a <a>TextTag</a>. Configure the tag using object arguments,
--   i.e. using <tt><i>g_object_set()</i></tt>.
textTagNew :: (HasCallStack, MonadIO m) => Maybe Text -> m TextTag

-- | Emits the <a>TextTagTable::tagChanged</a> signal on the
--   <a>TextTagTable</a> where the tag is included.
--   
--   The signal is already emitted when setting a <a>TextTag</a> property.
--   This function is useful for a <a>TextTag</a> subclass.
--   
--   <i>Since: 3.20</i>
textTagChanged :: (HasCallStack, MonadIO m, IsTextTag a) => a -> Bool -> m ()

-- | Emits the “event” signal on the <a>TextTag</a>.
textTagEvent :: (HasCallStack, MonadIO m, IsTextTag a, IsObject b) => a -> b -> Event -> TextIter -> m Bool

-- | Get the tag priority.
textTagGetPriority :: (HasCallStack, MonadIO m, IsTextTag a) => a -> m Int32

-- | Sets the priority of a <a>TextTag</a>. Valid priorities start at 0 and
--   go to one less than <a>textTagTableGetSize</a>. Each tag in a table
--   has a unique priority; setting the priority of one tag shifts the
--   priorities of all the other tags in the table to maintain a unique
--   priority for each tag. Higher priority tags “win” if two tags both set
--   the same text attribute. When adding a tag to a tag table, it will be
--   assigned the highest priority in the table by default; so normally the
--   precedence of a set of tags is the order in which they were added to
--   the table, or created with
--   <tt><i>gtk_text_buffer_create_tag()</i></tt>, which adds the tag to
--   the buffer’s table automatically.
textTagSetPriority :: (HasCallStack, MonadIO m, IsTextTag a) => a -> Int32 -> m ()

-- | Get the value of the “<tt>left-gravity</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textMark #leftGravity
--   </pre>
getTextMarkLeftGravity :: (MonadIO m, IsTextMark o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>left-gravity</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextMarkLeftGravity :: (IsTextMark o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textMark #name
--   </pre>
getTextMarkName :: (MonadIO m, IsTextMark o) => o -> m (Maybe Text)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>name</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextMarkName :: (IsTextMark o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Creates a text mark. Add it to a buffer using
--   <a>textBufferAddMark</a>. If <i><tt>name</tt></i> is <a>Nothing</a>,
--   the mark is anonymous; otherwise, the mark can be retrieved by name
--   using <a>textBufferGetMark</a>. If a mark has left gravity, and text
--   is inserted at the mark’s current location, the mark will be moved to
--   the left of the newly-inserted text. If the mark has right gravity
--   (<i><tt>leftGravity</tt></i> = <a>False</a>), the mark will end up on
--   the right of newly-inserted text. The standard left-to-right cursor is
--   a mark with right gravity (when you type, the cursor stays on the
--   right side of the text you’re typing).
--   
--   <i>Since: 2.12</i>
textMarkNew :: (HasCallStack, MonadIO m) => Maybe Text -> Bool -> m TextMark

-- | Gets the buffer this mark is located inside, or <a>Nothing</a> if the
--   mark is deleted.
textMarkGetBuffer :: (HasCallStack, MonadIO m, IsTextMark a) => a -> m TextBuffer

-- | Determines whether the mark has left gravity.
textMarkGetLeftGravity :: (HasCallStack, MonadIO m, IsTextMark a) => a -> m Bool

-- | Returns the mark name; returns NULL for anonymous marks.
textMarkGetName :: (HasCallStack, MonadIO m, IsTextMark a) => a -> m (Maybe Text)

-- | Returns <a>True</a> if the mark is visible (i.e. a cursor is displayed
--   for it).
textMarkGetVisible :: (HasCallStack, MonadIO m, IsTextMark a) => a -> m Bool

-- | Sets the visibility of <i><tt>mark</tt></i>; the insertion point is
--   normally visible, i.e. you can see it as a vertical bar. Also, the
--   text widget uses a visible mark to indicate where a drop will occur
--   when dragging-and-dropping text. Most other marks are not visible.
--   Marks are not visible by default.
textMarkSetVisible :: (HasCallStack, MonadIO m, IsTextMark a) => a -> Bool -> m ()

-- | Determines whether a child anchor has been deleted from the buffer.
--   Keep in mind that the child anchor will be unreferenced when removed
--   from the buffer, so you need to hold your own reference (with
--   <a>objectRef</a>) if you plan to use this function — otherwise all
--   deleted child anchors will also be finalized.
textChildAnchorGetDeleted :: (HasCallStack, MonadIO m, IsTextChildAnchor a) => a -> m Bool

-- | Gets a list of all widgets anchored at this child anchor. The returned
--   list should be freed with <tt><i>g_list_free()</i></tt>.
textChildAnchorGetWidgets :: (HasCallStack, MonadIO m, IsTextChildAnchor a) => a -> m [Widget]

-- | Connect a signal handler for the <a>applyTag</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #applyTag callback
--   </pre>
onTextBufferApplyTag :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferApplyTagCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>applyTag</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #applyTag callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferApplyTag :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferApplyTagCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>beginUserAction</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #beginUserAction callback
--   </pre>
onTextBufferBeginUserAction :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferBeginUserActionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>beginUserAction</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #beginUserAction callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferBeginUserAction :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferBeginUserActionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #changed callback
--   </pre>
onTextBufferChanged :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferChanged :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteRange</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #deleteRange callback
--   </pre>
onTextBufferDeleteRange :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferDeleteRangeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteRange</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #deleteRange callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferDeleteRange :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferDeleteRangeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>endUserAction</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #endUserAction callback
--   </pre>
onTextBufferEndUserAction :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferEndUserActionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>endUserAction</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #endUserAction callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferEndUserAction :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferEndUserActionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertChildAnchor</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #insertChildAnchor callback
--   </pre>
onTextBufferInsertChildAnchor :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertChildAnchorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertChildAnchor</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #insertChildAnchor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferInsertChildAnchor :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertChildAnchorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertPixbuf</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #insertPixbuf callback
--   </pre>
onTextBufferInsertPixbuf :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertPixbufCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertPixbuf</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #insertPixbuf callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferInsertPixbuf :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertPixbufCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertText</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #insertText callback
--   </pre>
onTextBufferInsertText :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertText</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #insertText callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferInsertText :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>markDeleted</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #markDeleted callback
--   </pre>
onTextBufferMarkDeleted :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferMarkDeletedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>markDeleted</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #markDeleted callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferMarkDeleted :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferMarkDeletedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>markSet</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #markSet callback
--   </pre>
onTextBufferMarkSet :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferMarkSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>markSet</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #markSet callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferMarkSet :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferMarkSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>modifiedChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #modifiedChanged callback
--   </pre>
onTextBufferModifiedChanged :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferModifiedChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>modifiedChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #modifiedChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferModifiedChanged :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferModifiedChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pasteDone</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #pasteDone callback
--   </pre>
onTextBufferPasteDone :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferPasteDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pasteDone</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #pasteDone callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferPasteDone :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferPasteDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>removeTag</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #removeTag callback
--   </pre>
onTextBufferRemoveTag :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferRemoveTagCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>removeTag</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #removeTag callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferRemoveTag :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferRemoveTagCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>copy-target-list</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textBuffer #copyTargetList
--   </pre>
getTextBufferCopyTargetList :: (MonadIO m, IsTextBuffer o) => o -> m TargetList

-- | Get the value of the “<tt>cursor-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textBuffer #cursorPosition
--   </pre>
getTextBufferCursorPosition :: (MonadIO m, IsTextBuffer o) => o -> m Int32

-- | Get the value of the “<tt>has-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textBuffer #hasSelection
--   </pre>
getTextBufferHasSelection :: (MonadIO m, IsTextBuffer o) => o -> m Bool

-- | Get the value of the “<tt>paste-target-list</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textBuffer #pasteTargetList
--   </pre>
getTextBufferPasteTargetList :: (MonadIO m, IsTextBuffer o) => o -> m TargetList

-- | Get the value of the “<tt>tag-table</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textBuffer #tagTable
--   </pre>
getTextBufferTagTable :: (MonadIO m, IsTextBuffer o) => o -> m TextTagTable

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tag-table</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextBufferTagTable :: (IsTextBuffer o, MonadIO m, IsTextTagTable a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textBuffer #text
--   </pre>
getTextBufferText :: (MonadIO m, IsTextBuffer o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textBuffer [ #text <a>:=</a> value ]
--   </pre>
setTextBufferText :: (MonadIO m, IsTextBuffer o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextBufferText :: (IsTextBuffer o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>text</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #text
--   </pre>
clearTextBufferText :: (MonadIO m, IsTextBuffer o) => o -> m ()

-- | Creates a new text buffer.
textBufferNew :: (HasCallStack, MonadIO m, IsTextTagTable a) => Maybe a -> m TextBuffer

-- | Adds <i><tt>clipboard</tt></i> to the list of clipboards in which the
--   selection contents of <i><tt>buffer</tt></i> are available. In most
--   cases, <i><tt>clipboard</tt></i> will be the <a>Clipboard</a> of type
--   <tt><i>GDK_SELECTION_PRIMARY</i></tt> for a view of
--   <i><tt>buffer</tt></i>.
textBufferAddSelectionClipboard :: (HasCallStack, MonadIO m, IsTextBuffer a, IsClipboard b) => a -> b -> m ()

-- | Emits the “apply-tag” signal on <i><tt>buffer</tt></i>. The default
--   handler for the signal applies <i><tt>tag</tt></i> to the given range.
--   <i><tt>start</tt></i> and <i><tt>end</tt></i> do not have to be in
--   order.
textBufferApplyTag :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextTag b) => a -> b -> TextIter -> TextIter -> m ()

-- | Calls <a>textTagTableLookup</a> on the buffer’s tag table to get a
--   <a>TextTag</a>, then calls <a>textBufferApplyTag</a>.
textBufferApplyTagByName :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> TextIter -> TextIter -> m ()

-- | Performs the appropriate action as if the user hit the delete key with
--   the cursor at the position specified by <i><tt>iter</tt></i>. In the
--   normal case a single character will be deleted, but when combining
--   accents are involved, more than one character can be deleted, and when
--   precomposed character and accent combinations are involved, less than
--   one character will be deleted.
--   
--   Because the buffer is modified, all outstanding iterators become
--   invalid after calling this function; however, the <i><tt>iter</tt></i>
--   will be re-initialized to point to the location where text was
--   deleted.
--   
--   <i>Since: 2.6</i>
textBufferBackspace :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> Bool -> Bool -> m Bool

-- | Called to indicate that the buffer operations between here and a call
--   to <a>textBufferEndUserAction</a> are part of a single user-visible
--   operation. The operations between <a>textBufferBeginUserAction</a> and
--   <a>textBufferEndUserAction</a> can then be grouped when creating an
--   undo stack. <a>TextBuffer</a> maintains a count of calls to
--   <a>textBufferBeginUserAction</a> that have not been closed with a call
--   to <a>textBufferEndUserAction</a>, and emits the “begin-user-action”
--   and “end-user-action” signals only for the outermost pair of calls.
--   This allows you to build user actions from other user actions.
--   
--   The “interactive” buffer mutation functions, such as
--   <a>textBufferInsertInteractive</a>, automatically call begin/end user
--   action around the buffer operations they perform, so there's no need
--   to add extra calls if you user action consists solely of a single call
--   to one of those functions.
textBufferBeginUserAction :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m ()

-- | Copies the currently-selected text to a clipboard.
textBufferCopyClipboard :: (HasCallStack, MonadIO m, IsTextBuffer a, IsClipboard b) => a -> b -> m ()

-- | Creates a mark at position <i><tt>where</tt></i>. If
--   <i><tt>markName</tt></i> is <a>Nothing</a>, the mark is anonymous;
--   otherwise, the mark can be retrieved by name using
--   <a>textBufferGetMark</a>. If a mark has left gravity, and text is
--   inserted at the mark’s current location, the mark will be moved to the
--   left of the newly-inserted text. If the mark has right gravity
--   (<i><tt>leftGravity</tt></i> = <a>False</a>), the mark will end up on
--   the right of newly-inserted text. The standard left-to-right cursor is
--   a mark with right gravity (when you type, the cursor stays on the
--   right side of the text you’re typing).
--   
--   The caller of this function does not own a reference to the returned
--   <a>TextMark</a>, so you can ignore the return value if you like. Marks
--   are owned by the buffer and go away when the buffer does.
--   
--   Emits the <a>TextBuffer::markSet</a> signal as notification of the
--   mark's initial placement.
textBufferCreateMark :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Maybe Text -> TextIter -> Bool -> m TextMark

-- | Copies the currently-selected text to a clipboard, then deletes said
--   text if it’s editable.
textBufferCutClipboard :: (HasCallStack, MonadIO m, IsTextBuffer a, IsClipboard b) => a -> b -> Bool -> m ()

-- | Deletes text between <i><tt>start</tt></i> and <i><tt>end</tt></i>.
--   The order of <i><tt>start</tt></i> and <i><tt>end</tt></i> is not
--   actually relevant; <a>textBufferDelete</a> will reorder them. This
--   function actually emits the “delete-range” signal, and the default
--   handler of that signal deletes the text. Because the buffer is
--   modified, all outstanding iterators become invalid after calling this
--   function; however, the <i><tt>start</tt></i> and <i><tt>end</tt></i>
--   will be re-initialized to point to the location where text was
--   deleted.
textBufferDelete :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> m ()

-- | Deletes all editable text in the given range. Calls
--   <a>textBufferDelete</a> for each editable sub-range of
--   [<i><tt>start</tt></i>,<i><tt>end</tt></i>). <i><tt>start</tt></i> and
--   <i><tt>end</tt></i> are revalidated to point to the location of the
--   last deleted range, or left untouched if no text was deleted.
textBufferDeleteInteractive :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> Bool -> m Bool

-- | Deletes the mark named <i><tt>name</tt></i>; the mark must exist. See
--   <a>textBufferDeleteMark</a> for details.
textBufferDeleteMarkByName :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> m ()

-- | Deletes the range between the “insert” and “selection_bound” marks,
--   that is, the currently-selected text. If <i><tt>interactive</tt></i>
--   is <a>True</a>, the editability of the selection will be considered
--   (users can’t delete uneditable text).
textBufferDeleteSelection :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Bool -> Bool -> m Bool

-- | This function deserializes rich text in format <i><tt>format</tt></i>
--   and inserts it at <i><tt>iter</tt></i>.
--   
--   <i><tt>formats</tt></i> to be used must be registered using
--   <a>textBufferRegisterDeserializeFormat</a> or
--   <a>textBufferRegisterDeserializeTagset</a> beforehand.
--   
--   <i>Since: 2.10</i>
textBufferDeserialize :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextBuffer b) => a -> b -> Atom -> TextIter -> ByteString -> m ()

-- | This functions returns the value set with
--   <a>textBufferDeserializeSetCanCreateTags</a>
--   
--   <i>Since: 2.10</i>
textBufferDeserializeGetCanCreateTags :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Atom -> m Bool

-- | Use this function to allow a rich text deserialization function to
--   create new tags in the receiving buffer. Note that using this function
--   is almost always a bad idea, because the rich text functions you
--   register should know how to map the rich text format they handler to
--   your text buffers set of tags.
--   
--   The ability of creating new (arbitrary!) tags in the receiving buffer
--   is meant for special rich text formats like the internal one that is
--   registered using <a>textBufferRegisterDeserializeTagset</a>, because
--   that format is essentially a dump of the internal structure of the
--   source buffer, including its tag names.
--   
--   You should allow creation of tags only if you know what you are doing,
--   e.g. if you defined a tagset name for your application suite’s text
--   buffers and you know that it’s fine to receive new tags from these
--   buffers, because you know that your application can handle the newly
--   created tags.
--   
--   <i>Since: 2.10</i>
textBufferDeserializeSetCanCreateTags :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Atom -> Bool -> m ()

-- | Should be paired with a call to <a>textBufferBeginUserAction</a>. See
--   that function for a full explanation.
textBufferEndUserAction :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m ()

-- | Retrieves the first and last iterators in the buffer, i.e. the entire
--   buffer lies within the range
--   [<i><tt>start</tt></i>,<i><tt>end</tt></i>).
textBufferGetBounds :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m (TextIter, TextIter)

-- | Gets the number of characters in the buffer; note that characters and
--   bytes are not the same, you can’t e.g. expect the contents of the
--   buffer in string form to be this many bytes long. The character count
--   is cached, so this function is very fast.
textBufferGetCharCount :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m Int32

-- | This function returns the rich text deserialize formats registered
--   with <i><tt>buffer</tt></i> using
--   <a>textBufferRegisterDeserializeFormat</a> or
--   <a>textBufferRegisterDeserializeTagset</a>
--   
--   <i>Since: 2.10</i>
textBufferGetDeserializeFormats :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m [Atom]

-- | Initializes <i><tt>iter</tt></i> with the “end iterator,” one past the
--   last valid character in the text buffer. If dereferenced with
--   <a>textIterGetChar</a>, the end iterator has a character value of 0.
--   The entire buffer lies in the range from the first position in the
--   buffer (call <a>textBufferGetStartIter</a> to get character position
--   0) to the end iterator.
textBufferGetEndIter :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TextIter

-- | Indicates whether the buffer has some text currently selected.
--   
--   <i>Since: 2.10</i>
textBufferGetHasSelection :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m Bool

-- | Returns the mark that represents the cursor (insertion point).
--   Equivalent to calling <a>textBufferGetMark</a> to get the mark named
--   “insert”, but very slightly more efficient, and involves less typing.
textBufferGetInsert :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TextMark

-- | Obtains the location of <i><tt>anchor</tt></i> within
--   <i><tt>buffer</tt></i>.
textBufferGetIterAtChildAnchor :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextChildAnchor b) => a -> b -> m TextIter

-- | Initializes <i><tt>iter</tt></i> to the start of the given line. If
--   <i><tt>lineNumber</tt></i> is greater than the number of lines in the
--   <i><tt>buffer</tt></i>, the end iterator is returned.
textBufferGetIterAtLine :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> m TextIter

-- | Obtains an iterator pointing to <i><tt>byteIndex</tt></i> within the
--   given line. <i><tt>byteIndex</tt></i> must be the start of a UTF-8
--   character. Note bytes, not characters; UTF-8 may encode one character
--   as multiple bytes.
--   
--   Before the 3.20 version, it was not allowed to pass an invalid
--   location.
--   
--   Since the 3.20 version, if <i><tt>lineNumber</tt></i> is greater than
--   the number of lines in the <i><tt>buffer</tt></i>, the end iterator is
--   returned. And if <i><tt>byteIndex</tt></i> is off the end of the line,
--   the iterator at the end of the line is returned.
textBufferGetIterAtLineIndex :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> Int32 -> m TextIter

-- | Obtains an iterator pointing to <i><tt>charOffset</tt></i> within the
--   given line. Note characters, not bytes; UTF-8 may encode one character
--   as multiple bytes.
--   
--   Before the 3.20 version, it was not allowed to pass an invalid
--   location.
--   
--   Since the 3.20 version, if <i><tt>lineNumber</tt></i> is greater than
--   the number of lines in the <i><tt>buffer</tt></i>, the end iterator is
--   returned. And if <i><tt>charOffset</tt></i> is off the end of the
--   line, the iterator at the end of the line is returned.
textBufferGetIterAtLineOffset :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> Int32 -> m TextIter

-- | Initializes <i><tt>iter</tt></i> with the current position of
--   <i><tt>mark</tt></i>.
textBufferGetIterAtMark :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextMark b) => a -> b -> m TextIter

-- | Obtains the number of lines in the buffer. This value is cached, so
--   the function is very fast.
textBufferGetLineCount :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m Int32

-- | Indicates whether the buffer has been modified since the last call to
--   <a>textBufferSetModified</a> set the modification flag to
--   <a>False</a>. Used for example to enable a “save” function in a text
--   editor.
textBufferGetModified :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m Bool

-- | Returns the mark that represents the selection bound. Equivalent to
--   calling <a>textBufferGetMark</a> to get the mark named
--   “selection_bound”, but very slightly more efficient, and involves less
--   typing.
--   
--   The currently-selected text in <i><tt>buffer</tt></i> is the region
--   between the “selection_bound” and “insert” marks. If “selection_bound”
--   and “insert” are in the same place, then there is no current
--   selection. <a>textBufferGetSelectionBounds</a> is another convenient
--   function for handling the selection, if you just want to know whether
--   there’s a selection and what its bounds are.
textBufferGetSelectionBound :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TextMark

-- | Returns <a>True</a> if some text is selected; places the bounds of the
--   selection in <i><tt>start</tt></i> and <i><tt>end</tt></i> (if the
--   selection has length 0, then <i><tt>start</tt></i> and
--   <i><tt>end</tt></i> are filled in with the same value).
--   <i><tt>start</tt></i> and <i><tt>end</tt></i> will be in ascending
--   order. If <i><tt>start</tt></i> and <i><tt>end</tt></i> are NULL, then
--   they are not filled in, but the return value still indicates whether
--   text is selected.
textBufferGetSelectionBounds :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m (Bool, TextIter, TextIter)

-- | This function returns the rich text serialize formats registered with
--   <i><tt>buffer</tt></i> using <a>textBufferRegisterSerializeFormat</a>
--   or <a>textBufferRegisterSerializeTagset</a>
--   
--   <i>Since: 2.10</i>
textBufferGetSerializeFormats :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m [Atom]

-- | Returns the text in the range
--   [<i><tt>start</tt></i>,<i><tt>end</tt></i>). Excludes undisplayed text
--   (text marked with tags that set the invisibility attribute) if
--   <i><tt>includeHiddenChars</tt></i> is <a>False</a>. The returned
--   string includes a 0xFFFC character whenever the buffer contains
--   embedded images, so byte and character indexes into the returned
--   string do correspond to byte and character indexes into the buffer.
--   Contrast with <a>textBufferGetText</a>. Note that 0xFFFC can occur in
--   normal text as well, so it is not a reliable indicator that a pixbuf
--   or widget is in the buffer.
textBufferGetSlice :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> Bool -> m Text

-- | Initialized <i><tt>iter</tt></i> with the first position in the text
--   buffer. This is the same as using <a>textBufferGetIterAtOffset</a> to
--   get the iter at character offset 0.
textBufferGetStartIter :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TextIter

-- | Get the <a>TextTagTable</a> associated with this buffer.
textBufferGetTagTable :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TextTagTable

-- | Returns the text in the range
--   [<i><tt>start</tt></i>,<i><tt>end</tt></i>). Excludes undisplayed text
--   (text marked with tags that set the invisibility attribute) if
--   <i><tt>includeHiddenChars</tt></i> is <a>False</a>. Does not include
--   characters representing embedded images, so byte and character indexes
--   into the returned string do not correspond to byte and character
--   indexes into the buffer. Contrast with <a>textBufferGetSlice</a>.
textBufferGetText :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> Bool -> m Text

-- | Inserts <i><tt>len</tt></i> bytes of <i><tt>text</tt></i> at position
--   <i><tt>iter</tt></i>. If <i><tt>len</tt></i> is -1,
--   <i><tt>text</tt></i> must be nul-terminated and will be inserted in
--   its entirety. Emits the “insert-text” signal; insertion actually
--   occurs in the default handler for the signal. <i><tt>iter</tt></i> is
--   invalidated when insertion occurs (because the buffer contents
--   change), but the default signal handler revalidates it to point to the
--   end of the inserted text.
textBufferInsert :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> Text -> Int32 -> m ()

-- | Simply calls <a>textBufferInsert</a>, using the current cursor
--   position as the insertion point.
textBufferInsertAtCursor :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> Int32 -> m ()

-- | Calls <a>textBufferInsertInteractive</a> at the cursor position.
--   
--   <i><tt>defaultEditable</tt></i> indicates the editability of text that
--   doesn't have a tag affecting editability applied to it. Typically the
--   result of <a>textViewGetEditable</a> is appropriate here.
textBufferInsertInteractiveAtCursor :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> Int32 -> Bool -> m Bool

-- | Inserts the text in <i><tt>markup</tt></i> at position
--   <i><tt>iter</tt></i>. <i><tt>markup</tt></i> will be inserted in its
--   entirety and must be nul-terminated and valid UTF-8. Emits the
--   <a>TextBuffer::insertText</a> signal, possibly multiple times;
--   insertion actually occurs in the default handler for the signal.
--   <i><tt>iter</tt></i> will point to the end of the inserted text on
--   return.
--   
--   <i>Since: 3.16</i>
textBufferInsertMarkup :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> Text -> Int32 -> m ()

-- | Inserts an image into the text buffer at <i><tt>iter</tt></i>. The
--   image will be counted as one character in character counts, and when
--   obtaining the buffer contents as a string, will be represented by the
--   Unicode “object replacement character” 0xFFFC. Note that the “slice”
--   variants for obtaining portions of the buffer as a string include this
--   character for pixbufs, but the “text” variants do not. e.g. see
--   <a>textBufferGetSlice</a> and <a>textBufferGetText</a>.
textBufferInsertPixbuf :: (HasCallStack, MonadIO m, IsTextBuffer a, IsPixbuf b) => a -> TextIter -> b -> m ()

-- | Copies text, tags, and pixbufs between <i><tt>start</tt></i> and
--   <i><tt>end</tt></i> (the order of <i><tt>start</tt></i> and
--   <i><tt>end</tt></i> doesn’t matter) and inserts the copy at
--   <i><tt>iter</tt></i>. Used instead of simply getting/inserting text
--   because it preserves images and tags. If <i><tt>start</tt></i> and
--   <i><tt>end</tt></i> are in a different buffer from
--   <i><tt>buffer</tt></i>, the two buffers must share the same tag table.
--   
--   Implemented via emissions of the insert_text and apply_tag signals, so
--   expect those.
textBufferInsertRange :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> TextIter -> m ()

-- | Same as <a>textBufferInsertRange</a>, but does nothing if the
--   insertion point isn’t editable. The <i><tt>defaultEditable</tt></i>
--   parameter indicates whether the text is editable at
--   <i><tt>iter</tt></i> if no tags enclosing <i><tt>iter</tt></i> affect
--   editability. Typically the result of <a>textViewGetEditable</a> is
--   appropriate here.
textBufferInsertRangeInteractive :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> TextIter -> Bool -> m Bool

-- | Moves <i><tt>mark</tt></i> to the new location <i><tt>where</tt></i>.
--   Emits the <a>TextBuffer::markSet</a> signal as notification of the
--   move.
textBufferMoveMark :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextMark b) => a -> b -> TextIter -> m ()

-- | Moves the mark named <i><tt>name</tt></i> (which must exist) to
--   location <i><tt>where</tt></i>. See <a>textBufferMoveMark</a> for
--   details.
textBufferMoveMarkByName :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> TextIter -> m ()

-- | Pastes the contents of a clipboard. If
--   <i><tt>overrideLocation</tt></i> is <a>Nothing</a>, the pasted text
--   will be inserted at the cursor position, or the buffer selection will
--   be replaced if the selection is non-empty.
--   
--   Note: pasting is asynchronous, that is, we’ll ask for the paste data
--   and return, and at some point later after the main loop runs, the
--   paste data will be inserted.
textBufferPasteClipboard :: (HasCallStack, MonadIO m, IsTextBuffer a, IsClipboard b) => a -> b -> Maybe TextIter -> Bool -> m ()

-- | This function moves the “insert” and “selection_bound” marks
--   simultaneously. If you move them to the same place in two steps with
--   <a>textBufferMoveMark</a>, you will temporarily select a region in
--   between their old and new locations, which can be pretty inefficient
--   since the temporarily-selected region will force stuff to be
--   recalculated. This function moves them as a unit, which can be
--   optimized.
textBufferPlaceCursor :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> m ()

-- | This function registers GTK+’s internal rich text serialization format
--   with the passed <i><tt>buffer</tt></i>. See
--   <a>textBufferRegisterSerializeTagset</a> for details.
--   
--   <i>Since: 2.10</i>
textBufferRegisterDeserializeTagset :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Maybe Text -> m Atom

-- | This function registers GTK+’s internal rich text serialization format
--   with the passed <i><tt>buffer</tt></i>. The internal format does not
--   comply to any standard rich text format and only works between
--   <a>TextBuffer</a> instances. It is capable of serializing all of a
--   text buffer’s tags and embedded pixbufs.
--   
--   This function is just a wrapper around
--   <a>textBufferRegisterSerializeFormat</a>. The mime type used for
--   registering is “application/x-gtk-text-buffer-rich-text”, or
--   “application/x-gtk-text-buffer-rich-text;format=<i><tt>tagsetName</tt></i>”
--   if a <i><tt>tagsetName</tt></i> was passed.
--   
--   The <i><tt>tagsetName</tt></i> can be used to restrict the transfer of
--   rich text to buffers with compatible sets of tags, in order to avoid
--   unknown tags from being pasted. It is probably the common case to pass
--   an identifier != <a>Nothing</a> here, since the <a>Nothing</a> tagset
--   requires the receiving buffer to deal with with pasting of arbitrary
--   tags.
--   
--   <i>Since: 2.10</i>
textBufferRegisterSerializeTagset :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Maybe Text -> m Atom

-- | Removes all tags in the range between <i><tt>start</tt></i> and
--   <i><tt>end</tt></i>. Be careful with this function; it could remove
--   tags added in code unrelated to the code you’re currently writing.
--   That is, using this function is probably a bad idea if you have two or
--   more unrelated code sections that add tags.
textBufferRemoveAllTags :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> m ()

-- | Removes a <a>Clipboard</a> added with
--   <a>textBufferAddSelectionClipboard</a>.
textBufferRemoveSelectionClipboard :: (HasCallStack, MonadIO m, IsTextBuffer a, IsClipboard b) => a -> b -> m ()

-- | Emits the “remove-tag” signal. The default handler for the signal
--   removes all occurrences of <i><tt>tag</tt></i> from the given range.
--   <i><tt>start</tt></i> and <i><tt>end</tt></i> don’t have to be in
--   order.
textBufferRemoveTag :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextTag b) => a -> b -> TextIter -> TextIter -> m ()

-- | Calls <a>textTagTableLookup</a> on the buffer’s tag table to get a
--   <a>TextTag</a>, then calls <a>textBufferRemoveTag</a>.
textBufferRemoveTagByName :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> TextIter -> TextIter -> m ()

-- | This function moves the “insert” and “selection_bound” marks
--   simultaneously. If you move them in two steps with
--   <a>textBufferMoveMark</a>, you will temporarily select a region in
--   between their old and new locations, which can be pretty inefficient
--   since the temporarily-selected region will force stuff to be
--   recalculated. This function moves them as a unit, which can be
--   optimized.
--   
--   <i>Since: 2.4</i>
textBufferSelectRange :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> m ()

-- | Used to keep track of whether the buffer has been modified since the
--   last time it was saved. Whenever the buffer is saved to disk, call
--   gtk_text_buffer_set_modified (<i><tt>buffer</tt></i>, FALSE). When the
--   buffer is modified, it will automatically toggled on the modified bit
--   again. When the modified bit flips, the buffer emits the
--   <a>TextBuffer::modifiedChanged</a> signal.
textBufferSetModified :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Bool -> m ()

-- | Deletes current contents of <i><tt>buffer</tt></i>, and inserts
--   <i><tt>text</tt></i> instead. If <i><tt>len</tt></i> is -1,
--   <i><tt>text</tt></i> must be nul-terminated. <i><tt>text</tt></i> must
--   be valid UTF-8.
textBufferSetText :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> Int32 -> m ()

-- | This function unregisters a rich text format that was previously
--   registered using <a>textBufferRegisterDeserializeFormat</a> or
--   <a>textBufferRegisterDeserializeTagset</a>.
--   
--   <i>Since: 2.10</i>
textBufferUnregisterDeserializeFormat :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Atom -> m ()

-- | This function unregisters a rich text format that was previously
--   registered using <a>textBufferRegisterSerializeFormat</a> or
--   <a>textBufferRegisterSerializeTagset</a>
--   
--   <i>Since: 2.10</i>
textBufferUnregisterSerializeFormat :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Atom -> m ()

-- | Returns a newly created <a>StyleProperties</a>
stylePropertiesNew :: (HasCallStack, MonadIO m) => m StyleProperties

-- | Clears all style information from <i><tt>props</tt></i>.
stylePropertiesClear :: (HasCallStack, MonadIO m, IsStyleProperties a) => a -> m ()

-- | Gets a style property from <i><tt>props</tt></i> for the given state.
--   When done with <i><tt>value</tt></i>, <a>valueUnset</a> needs to be
--   called to free any allocated memory.
--   
--   <i>Since: 3.0</i>
stylePropertiesGetProperty :: (HasCallStack, MonadIO m, IsStyleProperties a) => a -> Text -> [StateFlags] -> m (Bool, GValue)

-- | Maps <i><tt>color</tt></i> so it can be referenced by
--   <i><tt>name</tt></i>. See <a>stylePropertiesLookupColor</a>
--   
--   <i>Since: 3.0</i>
stylePropertiesMapColor :: (HasCallStack, MonadIO m, IsStyleProperties a) => a -> Text -> SymbolicColor -> m ()

-- | Merges into <i><tt>props</tt></i> all the style information contained
--   in <i><tt>propsToMerge</tt></i>. If <i><tt>replace</tt></i> is
--   <a>True</a>, the values will be overwritten, if it is <a>False</a>,
--   the older values will prevail.
--   
--   <i>Since: 3.0</i>
stylePropertiesMerge :: (HasCallStack, MonadIO m, IsStyleProperties a, IsStyleProperties b) => a -> b -> Bool -> m ()

-- | Sets a styling property in <i><tt>props</tt></i>.
--   
--   <i>Since: 3.0</i>
stylePropertiesSetProperty :: (HasCallStack, MonadIO m, IsStyleProperties a) => a -> Text -> [StateFlags] -> GValue -> m ()

-- | Unsets a style property in <i><tt>props</tt></i>.
--   
--   <i>Since: 3.0</i>
stylePropertiesUnsetProperty :: (HasCallStack, MonadIO m, IsStyleProperties a) => a -> Text -> [StateFlags] -> m ()

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> styleContext #changed callback
--   </pre>
onStyleContextChanged :: (IsStyleContext a, MonadIO m) => a -> ((?self :: a) => StyleContextChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> styleContext #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterStyleContextChanged :: (IsStyleContext a, MonadIO m) => a -> ((?self :: a) => StyleContextChangedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> styleContext #direction
--   </pre>
getStyleContextDirection :: (MonadIO m, IsStyleContext o) => o -> m TextDirection

-- | Set the value of the “<tt>direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> styleContext [ #direction <a>:=</a> value ]
--   </pre>
setStyleContextDirection :: (MonadIO m, IsStyleContext o) => o -> TextDirection -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>direction</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructStyleContextDirection :: (IsStyleContext o, MonadIO m) => TextDirection -> m (GValueConstruct o)

-- | Get the value of the “<tt>paint-clock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> styleContext #paintClock
--   </pre>
getStyleContextPaintClock :: (MonadIO m, IsStyleContext o) => o -> m (Maybe FrameClock)

-- | Set the value of the “<tt>paint-clock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> styleContext [ #paintClock <a>:=</a> value ]
--   </pre>
setStyleContextPaintClock :: (MonadIO m, IsStyleContext o, IsFrameClock a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>paint-clock</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructStyleContextPaintClock :: (IsStyleContext o, MonadIO m, IsFrameClock a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>paint-clock</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #paintClock
--   </pre>
clearStyleContextPaintClock :: (MonadIO m, IsStyleContext o) => o -> m ()

-- | Get the value of the “<tt>parent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> styleContext #parent
--   </pre>
getStyleContextParent :: (MonadIO m, IsStyleContext o) => o -> m (Maybe StyleContext)

-- | Set the value of the “<tt>parent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> styleContext [ #parent <a>:=</a> value ]
--   </pre>
setStyleContextParent :: (MonadIO m, IsStyleContext o, IsStyleContext a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>parent</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStyleContextParent :: (IsStyleContext o, MonadIO m, IsStyleContext a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>parent</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #parent
--   </pre>
clearStyleContextParent :: (MonadIO m, IsStyleContext o) => o -> m ()

-- | Get the value of the “<tt>screen</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> styleContext #screen
--   </pre>
getStyleContextScreen :: (MonadIO m, IsStyleContext o) => o -> m Screen

-- | Set the value of the “<tt>screen</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> styleContext [ #screen <a>:=</a> value ]
--   </pre>
setStyleContextScreen :: (MonadIO m, IsStyleContext o, IsScreen a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>screen</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStyleContextScreen :: (IsStyleContext o, MonadIO m, IsScreen a) => a -> m (GValueConstruct o)

-- | Creates a standalone <a>StyleContext</a>, this style context won’t be
--   attached to any widget, so you may want to call
--   <a>styleContextSetPath</a> yourself.
--   
--   This function is only useful when using the theming layer separated
--   from GTK+, if you are using <a>StyleContext</a> to theme
--   <tt><i>GtkWidgets</i></tt>, use <a>widgetGetStyleContext</a> in order
--   to get a style context ready to theme the widget.
styleContextNew :: (HasCallStack, MonadIO m) => m StyleContext

-- | Adds a style provider to <i><tt>context</tt></i>, to be used in style
--   construction. Note that a style provider added by this function only
--   affects the style of the widget to which <i><tt>context</tt></i>
--   belongs. If you want to affect the style of all widgets, use
--   <a>styleContextAddProviderForScreen</a>.
--   
--   Note: If both priorities are the same, a <a>StyleProvider</a> added
--   through this function takes precedence over another added through
--   <a>styleContextAddProviderForScreen</a>.
--   
--   <i>Since: 3.0</i>
styleContextAddProvider :: (HasCallStack, MonadIO m, IsStyleContext a, IsStyleProvider b) => a -> b -> Word32 -> m ()

-- | Stops all running animations for <i><tt>regionId</tt></i> and all
--   animatable regions underneath.
--   
--   A <a>Nothing</a> <i><tt>regionId</tt></i> will stop all ongoing
--   animations in <i><tt>context</tt></i>, when dealing with a
--   <a>StyleContext</a> obtained through <a>widgetGetStyleContext</a>,
--   this is normally done for you in all circumstances you would expect
--   all widget to be stopped, so this should be only used in complex
--   widgets with different animatable regions.
--   
--   <i>Since: 3.0</i>
styleContextCancelAnimations :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Ptr () -> m ()

-- | Gets the background color for a given state.
--   
--   This function is far less useful than it seems, and it should not be
--   used in newly written code. CSS has no concept of "background color",
--   as a background can be an image, or a gradient, or any other pattern
--   including solid colors.
--   
--   The only reason why you would call
--   <a>styleContextGetBackgroundColor</a> is to use the returned value to
--   draw the background with it; the correct way to achieve this result is
--   to use <a>renderBackground</a> instead, along with CSS style classes
--   to modify the color to be rendered.
--   
--   <i>Since: 3.0</i>
styleContextGetBackgroundColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m RGBA

-- | Gets the border for a given state as a <a>Border</a>.
--   
--   See <a>styleContextGetProperty</a> and
--   <a>STYLE_PROPERTY_BORDER_WIDTH</a> for details.
--   
--   <i>Since: 3.0</i>
styleContextGetBorder :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m Border

-- | Gets the border color for a given state.
--   
--   <i>Since: 3.0</i>
styleContextGetBorderColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m RGBA

-- | Gets the foreground color for a given state.
--   
--   See <a>styleContextGetProperty</a> and <a>STYLE_PROPERTY_COLOR</a> for
--   details.
--   
--   <i>Since: 3.0</i>
styleContextGetColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m RGBA

-- | Returns the widget direction used for rendering.
--   
--   <i>Since: 3.0</i>
styleContextGetDirection :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m TextDirection

-- | Returns the font description for a given state. The returned object is
--   const and will remain valid until the <a>StyleContext::changed</a>
--   signal happens.
--   
--   <i>Since: 3.0</i>
styleContextGetFont :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m FontDescription

-- | Returns the <a>FrameClock</a> to which <i><tt>context</tt></i> is
--   attached.
--   
--   <i>Since: 3.8</i>
styleContextGetFrameClock :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m (Maybe FrameClock)

-- | Returns the sides where rendered elements connect visually with
--   others.
--   
--   <i>Since: 3.0</i>
styleContextGetJunctionSides :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m [JunctionSides]

-- | Gets the margin for a given state as a <a>Border</a>. See
--   <tt><i>gtk_style_property_get()</i></tt> and
--   <a>STYLE_PROPERTY_MARGIN</a> for details.
--   
--   <i>Since: 3.0</i>
styleContextGetMargin :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m Border

-- | Gets the padding for a given state as a <a>Border</a>. See
--   <tt><i>gtk_style_context_get()</i></tt> and
--   <a>STYLE_PROPERTY_PADDING</a> for details.
--   
--   <i>Since: 3.0</i>
styleContextGetPadding :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m Border

-- | Gets the parent context set via <a>styleContextSetParent</a>. See that
--   function for details.
--   
--   <i>Since: 3.4</i>
styleContextGetParent :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m (Maybe StyleContext)

-- | Returns the widget path used for style matching.
--   
--   <i>Since: 3.0</i>
styleContextGetPath :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m WidgetPath

-- | Gets a style property from <i><tt>context</tt></i> for the given
--   state.
--   
--   Note that not all CSS properties that are supported by GTK+ can be
--   retrieved in this way, since they may not be representable as
--   <a>Value</a>. GTK+ defines macros for a number of properties that can
--   be used with this function.
--   
--   Note that passing a state other than the current state of
--   <i><tt>context</tt></i> is not recommended unless the style context
--   has been saved with <a>styleContextSave</a>.
--   
--   When <i><tt>value</tt></i> is no longer needed, <a>valueUnset</a> must
--   be called to free any allocated memory.
--   
--   <i>Since: 3.0</i>
styleContextGetProperty :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> [StateFlags] -> m GValue

-- | Returns the scale used for assets.
--   
--   <i>Since: 3.10</i>
styleContextGetScale :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m Int32

-- | Returns the <a>Screen</a> to which <i><tt>context</tt></i> is
--   attached.
styleContextGetScreen :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m Screen

-- | Queries the location in the CSS where <i><tt>property</tt></i> was
--   defined for the current <i><tt>context</tt></i>. Note that the state
--   to be queried is taken from <a>styleContextGetState</a>.
--   
--   If the location is not available, <a>Nothing</a> will be returned. The
--   location might not be available for various reasons, such as the
--   property being overridden, <i><tt>property</tt></i> not naming a
--   supported CSS property or tracking of definitions being disabled for
--   performance reasons.
--   
--   Shorthand CSS properties cannot be queried for a location and will
--   always return <a>Nothing</a>.
styleContextGetSection :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m (Maybe CssSection)

-- | Gets the value for a widget style property.
--   
--   When <i><tt>value</tt></i> is no longer needed, <a>valueUnset</a> must
--   be called to free any allocated memory.
styleContextGetStyleProperty :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> GValue -> m ()

-- | Returns <a>True</a> if <i><tt>context</tt></i> currently has defined
--   the given class name.
--   
--   <i>Since: 3.0</i>
styleContextHasClass :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m Bool

-- | Returns <a>True</a> if <i><tt>context</tt></i> has the region defined.
--   If <i><tt>flagsReturn</tt></i> is not <a>Nothing</a>, it is set to the
--   flags affecting the region.
--   
--   <i>Since: 3.0</i>
styleContextHasRegion :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m (Bool, [RegionFlags])

-- | Invalidates <i><tt>context</tt></i> style information, so it will be
--   reconstructed again. It is useful if you modify the
--   <i><tt>context</tt></i> and need the new information immediately.
--   
--   <i>Since: 3.0</i>
styleContextInvalidate :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m ()

-- | Returns the list of classes currently defined in
--   <i><tt>context</tt></i>.
--   
--   <i>Since: 3.0</i>
styleContextListClasses :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m [Text]

-- | Returns the list of regions currently defined in
--   <i><tt>context</tt></i>.
--   
--   <i>Since: 3.0</i>
styleContextListRegions :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m [Text]

-- | Looks up <i><tt>stockId</tt></i> in the icon factories associated to
--   <i><tt>context</tt></i> and the default icon factory, returning an
--   icon set if found, otherwise <a>Nothing</a>.
styleContextLookupIconSet :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m (Maybe IconSet)

-- | Notifies a state change on <i><tt>context</tt></i>, so if the current
--   style makes use of transition animations, one will be started so all
--   rendered elements under <i><tt>regionId</tt></i> are animated for
--   state <i><tt>state</tt></i> being set to value
--   <i><tt>stateValue</tt></i>.
--   
--   The <i><tt>window</tt></i> parameter is used in order to invalidate
--   the rendered area as the animation runs, so make sure it is the same
--   window that is being rendered on by the gtk_render_*() functions.
--   
--   If <i><tt>regionId</tt></i> is <a>Nothing</a>, all rendered elements
--   using <i><tt>context</tt></i> will be affected by this state
--   transition.
--   
--   As a practical example, a <a>Button</a> notifying a state transition
--   on the prelight state: &gt; <a>language="C" --</a>
--   &gt;gtk_style_context_notify_state_change (context, &gt;
--   gtk_widget_get_window (widget), &gt; NULL, &gt; GTK_STATE_PRELIGHT,
--   &gt; button-&gt;in_button);
--   
--   Can be handled in the CSS file like this: &gt; <a>language="CSS"
--   --</a> &gt;button { &gt; background-color: #f00 &gt;} &gt;
--   &gt;button:hover { &gt; background-color: #fff; &gt; transition: 200ms
--   linear &gt;}
--   
--   This combination will animate the button background from red to white
--   if a pointer enters the button, and back to red if the pointer leaves
--   the button.
--   
--   Note that <i><tt>state</tt></i> is used when finding the transition
--   parameters, which is why the style places the transition under the
--   :hover pseudo-class.
--   
--   <i>Since: 3.0</i>
styleContextNotifyStateChange :: (HasCallStack, MonadIO m, IsStyleContext a, IsWindow b) => a -> b -> Ptr () -> StateType -> Bool -> m ()

-- | Pops an animatable region from <i><tt>context</tt></i>. See
--   <a>styleContextPushAnimatableRegion</a>.
--   
--   <i>Since: 3.0</i>
styleContextPopAnimatableRegion :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m ()

-- | Removes <i><tt>className</tt></i> from <i><tt>context</tt></i>.
--   
--   <i>Since: 3.0</i>
styleContextRemoveClass :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m ()

-- | Removes <i><tt>provider</tt></i> from the style providers list in
--   <i><tt>context</tt></i>.
--   
--   <i>Since: 3.0</i>
styleContextRemoveProvider :: (HasCallStack, MonadIO m, IsStyleContext a, IsStyleProvider b) => a -> b -> m ()

-- | Removes a region from <i><tt>context</tt></i>.
--   
--   <i>Since: 3.0</i>
styleContextRemoveRegion :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m ()

-- | Restores <i><tt>context</tt></i> state to a previous stage. See
--   <a>styleContextSave</a>.
--   
--   <i>Since: 3.0</i>
styleContextRestore :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m ()

-- | Saves the <i><tt>context</tt></i> state, so temporary modifications
--   done through <a>styleContextAddClass</a>,
--   <a>styleContextRemoveClass</a>, <a>styleContextSetState</a>, etc. can
--   quickly be reverted in one go through <a>styleContextRestore</a>.
--   
--   The matching call to <a>styleContextRestore</a> must be done before
--   GTK returns to the main loop.
--   
--   <i>Since: 3.0</i>
styleContextSave :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m ()

-- | This function is analogous to <a>windowScroll</a>, and should be
--   called together with it so the invalidation areas for any ongoing
--   animation are scrolled together with it.
--   
--   <i>Since: 3.0</i>
styleContextScrollAnimations :: (HasCallStack, MonadIO m, IsStyleContext a, IsWindow b) => a -> b -> Int32 -> Int32 -> m ()

-- | Sets the background of <i><tt>window</tt></i> to the background
--   pattern or color specified in <i><tt>context</tt></i> for its current
--   state.
--   
--   <i>Since: 3.0</i>
styleContextSetBackground :: (HasCallStack, MonadIO m, IsStyleContext a, IsWindow b) => a -> b -> m ()

-- | Sets the reading direction for rendering purposes.
--   
--   If you are using a <a>StyleContext</a> returned from
--   <a>widgetGetStyleContext</a>, you do not need to call this yourself.
--   
--   <i>Since: 3.0</i>
styleContextSetDirection :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> TextDirection -> m ()

-- | Attaches <i><tt>context</tt></i> to the given frame clock.
--   
--   The frame clock is used for the timing of animations.
--   
--   If you are using a <a>StyleContext</a> returned from
--   <a>widgetGetStyleContext</a>, you do not need to call this yourself.
--   
--   <i>Since: 3.8</i>
styleContextSetFrameClock :: (HasCallStack, MonadIO m, IsStyleContext a, IsFrameClock b) => a -> b -> m ()

-- | Sets the sides where rendered elements (mostly through
--   <a>renderFrame</a>) will visually connect with other visual elements.
--   
--   This is merely a hint that may or may not be honored by themes.
--   
--   Container widgets are expected to set junction hints as appropriate
--   for their children, so it should not normally be necessary to call
--   this function manually.
--   
--   <i>Since: 3.0</i>
styleContextSetJunctionSides :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [JunctionSides] -> m ()

-- | Sets the parent style context for <i><tt>context</tt></i>. The parent
--   style context is used to implement <a>inheritance</a> of properties.
--   
--   If you are using a <a>StyleContext</a> returned from
--   <a>widgetGetStyleContext</a>, the parent will be set for you.
--   
--   <i>Since: 3.4</i>
styleContextSetParent :: (HasCallStack, MonadIO m, IsStyleContext a, IsStyleContext b) => a -> Maybe b -> m ()

-- | Sets the <a>WidgetPath</a> used for style matching. As a consequence,
--   the style will be regenerated to match the new given path.
--   
--   If you are using a <a>StyleContext</a> returned from
--   <a>widgetGetStyleContext</a>, you do not need to call this yourself.
--   
--   <i>Since: 3.0</i>
styleContextSetPath :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> WidgetPath -> m ()

-- | Sets the scale to use when getting image assets for the style.
--   
--   <i>Since: 3.10</i>
styleContextSetScale :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Int32 -> m ()

-- | Attaches <i><tt>context</tt></i> to the given screen.
--   
--   The screen is used to add style information from “global” style
--   providers, such as the screen’s <a>Settings</a> instance.
--   
--   If you are using a <a>StyleContext</a> returned from
--   <a>widgetGetStyleContext</a>, you do not need to call this yourself.
--   
--   <i>Since: 3.0</i>
styleContextSetScreen :: (HasCallStack, MonadIO m, IsStyleContext a, IsScreen b) => a -> b -> m ()

-- | Sets the state to be used for style matching.
--   
--   <i>Since: 3.0</i>
styleContextSetState :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m ()

-- | Returns <a>True</a> if there is a transition animation running for the
--   current region (see <a>styleContextPushAnimatableRegion</a>).
--   
--   If <i><tt>progress</tt></i> is not <a>Nothing</a>, the animation
--   progress will be returned there, 0.0 means the state is closest to
--   being unset, while 1.0 means it’s closest to being set. This means
--   transition animation will run from 0 to 1 when <i><tt>state</tt></i>
--   is being set and from 1 to 0 when it’s being unset.
--   
--   <i>Since: 3.0</i>
styleContextStateIsRunning :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> StateType -> m (Bool, Double)

-- | Adds a global style provider to <i><tt>screen</tt></i>, which will be
--   used in style construction for all <tt><i>GtkStyleContexts</i></tt>
--   under <i><tt>screen</tt></i>.
--   
--   GTK+ uses this to make styling information from <a>Settings</a>
--   available.
--   
--   Note: If both priorities are the same, A <a>StyleProvider</a> added
--   through <a>styleContextAddProvider</a> takes precedence over another
--   added through this function.
--   
--   <i>Since: 3.0</i>
styleContextAddProviderForScreen :: (HasCallStack, MonadIO m, IsScreen a, IsStyleProvider b) => a -> b -> Word32 -> m ()

-- | Removes <i><tt>provider</tt></i> from the global style providers list
--   in <i><tt>screen</tt></i>.
--   
--   <i>Since: 3.0</i>
styleContextRemoveProviderForScreen :: (HasCallStack, MonadIO m, IsScreen a, IsStyleProvider b) => a -> b -> m ()

-- | This function recomputes the styles for all widgets under a particular
--   <a>Screen</a>. This is useful when some global parameter has changed
--   that affects the appearance of all widgets, because when a widget gets
--   a new style, it will both redraw and recompute any cached information
--   about its appearance. As an example, it is used when the color scheme
--   changes in the related <a>Settings</a> object.
--   
--   <i>Since: 3.0</i>
styleContextResetWidgets :: (HasCallStack, MonadIO m, IsScreen a) => a -> m ()

-- | Connect a signal handler for the <a>realize</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> style #realize callback
--   </pre>
onStyleRealize :: (IsStyle a, MonadIO m) => a -> ((?self :: a) => StyleRealizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>realize</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> style #realize callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterStyleRealize :: (IsStyle a, MonadIO m) => a -> ((?self :: a) => StyleRealizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unrealize</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> style #unrealize callback
--   </pre>
onStyleUnrealize :: (IsStyle a, MonadIO m) => a -> ((?self :: a) => StyleUnrealizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unrealize</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> style #unrealize callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterStyleUnrealize :: (IsStyle a, MonadIO m) => a -> ((?self :: a) => StyleUnrealizeCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>context</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> style #context
--   </pre>
getStyleContext :: (MonadIO m, IsStyle o) => o -> m (Maybe StyleContext)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>context</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStyleContext :: (IsStyle o, MonadIO m, IsStyleContext a) => a -> m (GValueConstruct o)

-- | Creates a new <a>Style</a>.
styleNew :: (HasCallStack, MonadIO m) => m Style

-- | <i>No description available in the introspection data.</i>
styleApplyDefaultBackground :: (HasCallStack, MonadIO m, IsStyle a, IsWindow b) => a -> Context -> b -> StateType -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Creates a copy of the passed in <a>Style</a> object.
styleCopy :: (HasCallStack, MonadIO m, IsStyle a) => a -> m Style

-- | Detaches a style from a window. If the style is not attached to any
--   windows anymore, it is unrealized. See
--   <tt><i>gtk_style_attach()</i></tt>.
styleDetach :: (HasCallStack, MonadIO m, IsStyle a) => a -> m ()

-- | Queries the value of a style property corresponding to a widget class
--   is in the given style.
--   
--   <i>Since: 2.16</i>
styleGetStyleProperty :: (HasCallStack, MonadIO m, IsStyle a) => a -> GType -> Text -> m GValue

-- | Returns whether <i><tt>style</tt></i> has an associated
--   <a>StyleContext</a>.
--   
--   <i>Since: 3.0</i>
styleHasContext :: (HasCallStack, MonadIO m, IsStyle a) => a -> m Bool

-- | Looks up <i><tt>colorName</tt></i> in the style’s logical color
--   mappings, filling in <i><tt>color</tt></i> and returning <a>True</a>
--   if found, otherwise returning <a>False</a>. Do not cache the found
--   mapping, because it depends on the <a>Style</a> and might change when
--   a theme switch occurs.
--   
--   <i>Since: 2.10</i>
styleLookupColor :: (HasCallStack, MonadIO m, IsStyle a) => a -> Text -> m (Bool, Color)

-- | Sets the background of <i><tt>window</tt></i> to the background color
--   or pixmap specified by <i><tt>style</tt></i> for the given state.
styleSetBackground :: (HasCallStack, MonadIO m, IsStyle a, IsWindow b) => a -> b -> StateType -> m ()

-- | Get the value of the “<tt>gtk-alternative-button-order</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkAlternativeButtonOrder
--   </pre>
getSettingsGtkAlternativeButtonOrder :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-alternative-button-order</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkAlternativeButtonOrder <a>:=</a> value ]
--   </pre>
setSettingsGtkAlternativeButtonOrder :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-alternative-button-order</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructSettingsGtkAlternativeButtonOrder :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-alternative-sort-arrows</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkAlternativeSortArrows
--   </pre>
getSettingsGtkAlternativeSortArrows :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-alternative-sort-arrows</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkAlternativeSortArrows <a>:=</a> value ]
--   </pre>
setSettingsGtkAlternativeSortArrows :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-alternative-sort-arrows</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkAlternativeSortArrows :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-application-prefer-dark-theme</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkApplicationPreferDarkTheme
--   </pre>
getSettingsGtkApplicationPreferDarkTheme :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-application-prefer-dark-theme</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkApplicationPreferDarkTheme <a>:=</a> value ]
--   </pre>
setSettingsGtkApplicationPreferDarkTheme :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-application-prefer-dark-theme</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructSettingsGtkApplicationPreferDarkTheme :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-auto-mnemonics</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkAutoMnemonics
--   </pre>
getSettingsGtkAutoMnemonics :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-auto-mnemonics</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkAutoMnemonics <a>:=</a> value ]
--   </pre>
setSettingsGtkAutoMnemonics :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-auto-mnemonics</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkAutoMnemonics :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-button-images</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkButtonImages
--   </pre>
getSettingsGtkButtonImages :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-button-images</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkButtonImages <a>:=</a> value ]
--   </pre>
setSettingsGtkButtonImages :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-button-images</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkButtonImages :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-can-change-accels</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkCanChangeAccels
--   </pre>
getSettingsGtkCanChangeAccels :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-can-change-accels</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkCanChangeAccels <a>:=</a> value ]
--   </pre>
setSettingsGtkCanChangeAccels :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-can-change-accels</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkCanChangeAccels :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-color-palette</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkColorPalette
--   </pre>
getSettingsGtkColorPalette :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-color-palette</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkColorPalette <a>:=</a> value ]
--   </pre>
setSettingsGtkColorPalette :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-color-palette</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkColorPalette :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-color-palette</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkColorPalette
--   </pre>
clearSettingsGtkColorPalette :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-color-scheme</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkColorScheme
--   </pre>
getSettingsGtkColorScheme :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-color-scheme</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkColorScheme <a>:=</a> value ]
--   </pre>
setSettingsGtkColorScheme :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-color-scheme</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkColorScheme :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-color-scheme</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkColorScheme
--   </pre>
clearSettingsGtkColorScheme :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-cursor-aspect-ratio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkCursorAspectRatio
--   </pre>
getSettingsGtkCursorAspectRatio :: (MonadIO m, IsSettings o) => o -> m Float

-- | Set the value of the “<tt>gtk-cursor-aspect-ratio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkCursorAspectRatio <a>:=</a> value ]
--   </pre>
setSettingsGtkCursorAspectRatio :: (MonadIO m, IsSettings o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-cursor-aspect-ratio</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkCursorAspectRatio :: (IsSettings o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-cursor-blink</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkCursorBlink
--   </pre>
getSettingsGtkCursorBlink :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-cursor-blink</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkCursorBlink <a>:=</a> value ]
--   </pre>
setSettingsGtkCursorBlink :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-cursor-blink</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkCursorBlink :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-cursor-blink-time</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkCursorBlinkTime
--   </pre>
getSettingsGtkCursorBlinkTime :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-cursor-blink-time</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkCursorBlinkTime <a>:=</a> value ]
--   </pre>
setSettingsGtkCursorBlinkTime :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-cursor-blink-time</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkCursorBlinkTime :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-cursor-blink-timeout</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkCursorBlinkTimeout
--   </pre>
getSettingsGtkCursorBlinkTimeout :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-cursor-blink-timeout</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkCursorBlinkTimeout <a>:=</a> value ]
--   </pre>
setSettingsGtkCursorBlinkTimeout :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-cursor-blink-timeout</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkCursorBlinkTimeout :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-cursor-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkCursorThemeName
--   </pre>
getSettingsGtkCursorThemeName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-cursor-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkCursorThemeName <a>:=</a> value ]
--   </pre>
setSettingsGtkCursorThemeName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-cursor-theme-name</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkCursorThemeName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-cursor-theme-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkCursorThemeName
--   </pre>
clearSettingsGtkCursorThemeName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-cursor-theme-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkCursorThemeSize
--   </pre>
getSettingsGtkCursorThemeSize :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-cursor-theme-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkCursorThemeSize <a>:=</a> value ]
--   </pre>
setSettingsGtkCursorThemeSize :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-cursor-theme-size</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkCursorThemeSize :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-decoration-layout</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkDecorationLayout
--   </pre>
getSettingsGtkDecorationLayout :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-decoration-layout</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkDecorationLayout <a>:=</a> value ]
--   </pre>
setSettingsGtkDecorationLayout :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-decoration-layout</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkDecorationLayout :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-decoration-layout</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkDecorationLayout
--   </pre>
clearSettingsGtkDecorationLayout :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-dialogs-use-header</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkDialogsUseHeader
--   </pre>
getSettingsGtkDialogsUseHeader :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-dialogs-use-header</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkDialogsUseHeader <a>:=</a> value ]
--   </pre>
setSettingsGtkDialogsUseHeader :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-dialogs-use-header</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkDialogsUseHeader :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-dnd-drag-threshold</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkDndDragThreshold
--   </pre>
getSettingsGtkDndDragThreshold :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-dnd-drag-threshold</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkDndDragThreshold <a>:=</a> value ]
--   </pre>
setSettingsGtkDndDragThreshold :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-dnd-drag-threshold</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkDndDragThreshold :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-double-click-distance</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkDoubleClickDistance
--   </pre>
getSettingsGtkDoubleClickDistance :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-double-click-distance</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkDoubleClickDistance <a>:=</a> value ]
--   </pre>
setSettingsGtkDoubleClickDistance :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-double-click-distance</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkDoubleClickDistance :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-double-click-time</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkDoubleClickTime
--   </pre>
getSettingsGtkDoubleClickTime :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-double-click-time</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkDoubleClickTime <a>:=</a> value ]
--   </pre>
setSettingsGtkDoubleClickTime :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-double-click-time</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkDoubleClickTime :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-enable-accels</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkEnableAccels
--   </pre>
getSettingsGtkEnableAccels :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-enable-accels</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkEnableAccels <a>:=</a> value ]
--   </pre>
setSettingsGtkEnableAccels :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-enable-accels</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkEnableAccels :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-enable-animations</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkEnableAnimations
--   </pre>
getSettingsGtkEnableAnimations :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-enable-animations</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkEnableAnimations <a>:=</a> value ]
--   </pre>
setSettingsGtkEnableAnimations :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-enable-animations</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkEnableAnimations :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-enable-event-sounds</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkEnableEventSounds
--   </pre>
getSettingsGtkEnableEventSounds :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-enable-event-sounds</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkEnableEventSounds <a>:=</a> value ]
--   </pre>
setSettingsGtkEnableEventSounds :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-enable-event-sounds</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkEnableEventSounds :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-enable-input-feedback-sounds</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkEnableInputFeedbackSounds
--   </pre>
getSettingsGtkEnableInputFeedbackSounds :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-enable-input-feedback-sounds</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkEnableInputFeedbackSounds <a>:=</a> value ]
--   </pre>
setSettingsGtkEnableInputFeedbackSounds :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-enable-input-feedback-sounds</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructSettingsGtkEnableInputFeedbackSounds :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-enable-mnemonics</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkEnableMnemonics
--   </pre>
getSettingsGtkEnableMnemonics :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-enable-mnemonics</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkEnableMnemonics <a>:=</a> value ]
--   </pre>
setSettingsGtkEnableMnemonics :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-enable-mnemonics</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkEnableMnemonics :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-enable-primary-paste</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkEnablePrimaryPaste
--   </pre>
getSettingsGtkEnablePrimaryPaste :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-enable-primary-paste</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkEnablePrimaryPaste <a>:=</a> value ]
--   </pre>
setSettingsGtkEnablePrimaryPaste :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-enable-primary-paste</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkEnablePrimaryPaste :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-enable-tooltips</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkEnableTooltips
--   </pre>
getSettingsGtkEnableTooltips :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-enable-tooltips</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkEnableTooltips <a>:=</a> value ]
--   </pre>
setSettingsGtkEnableTooltips :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-enable-tooltips</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkEnableTooltips :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-entry-password-hint-timeout</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkEntryPasswordHintTimeout
--   </pre>
getSettingsGtkEntryPasswordHintTimeout :: (MonadIO m, IsSettings o) => o -> m Word32

-- | Set the value of the “<tt>gtk-entry-password-hint-timeout</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkEntryPasswordHintTimeout <a>:=</a> value ]
--   </pre>
setSettingsGtkEntryPasswordHintTimeout :: (MonadIO m, IsSettings o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-entry-password-hint-timeout</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructSettingsGtkEntryPasswordHintTimeout :: (IsSettings o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-entry-select-on-focus</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkEntrySelectOnFocus
--   </pre>
getSettingsGtkEntrySelectOnFocus :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-entry-select-on-focus</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkEntrySelectOnFocus <a>:=</a> value ]
--   </pre>
setSettingsGtkEntrySelectOnFocus :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-entry-select-on-focus</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkEntrySelectOnFocus :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-error-bell</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkErrorBell
--   </pre>
getSettingsGtkErrorBell :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-error-bell</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkErrorBell <a>:=</a> value ]
--   </pre>
setSettingsGtkErrorBell :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-error-bell</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkErrorBell :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-fallback-icon-theme</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkFallbackIconTheme
--   </pre>
getSettingsGtkFallbackIconTheme :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-fallback-icon-theme</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkFallbackIconTheme <a>:=</a> value ]
--   </pre>
setSettingsGtkFallbackIconTheme :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-fallback-icon-theme</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkFallbackIconTheme :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-fallback-icon-theme</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkFallbackIconTheme
--   </pre>
clearSettingsGtkFallbackIconTheme :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-file-chooser-backend</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkFileChooserBackend
--   </pre>
getSettingsGtkFileChooserBackend :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-file-chooser-backend</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkFileChooserBackend <a>:=</a> value ]
--   </pre>
setSettingsGtkFileChooserBackend :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-file-chooser-backend</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkFileChooserBackend :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-file-chooser-backend</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkFileChooserBackend
--   </pre>
clearSettingsGtkFileChooserBackend :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-font-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkFontName
--   </pre>
getSettingsGtkFontName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-font-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkFontName <a>:=</a> value ]
--   </pre>
setSettingsGtkFontName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-font-name</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSettingsGtkFontName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-font-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkFontName
--   </pre>
clearSettingsGtkFontName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-fontconfig-timestamp</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkFontconfigTimestamp
--   </pre>
getSettingsGtkFontconfigTimestamp :: (MonadIO m, IsSettings o) => o -> m Word32

-- | Set the value of the “<tt>gtk-fontconfig-timestamp</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkFontconfigTimestamp <a>:=</a> value ]
--   </pre>
setSettingsGtkFontconfigTimestamp :: (MonadIO m, IsSettings o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-fontconfig-timestamp</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkFontconfigTimestamp :: (IsSettings o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-icon-sizes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkIconSizes
--   </pre>
getSettingsGtkIconSizes :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-icon-sizes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkIconSizes <a>:=</a> value ]
--   </pre>
setSettingsGtkIconSizes :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-icon-sizes</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkIconSizes :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-icon-sizes</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkIconSizes
--   </pre>
clearSettingsGtkIconSizes :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-icon-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkIconThemeName
--   </pre>
getSettingsGtkIconThemeName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-icon-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkIconThemeName <a>:=</a> value ]
--   </pre>
setSettingsGtkIconThemeName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-icon-theme-name</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkIconThemeName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-icon-theme-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkIconThemeName
--   </pre>
clearSettingsGtkIconThemeName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-im-module</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkImModule
--   </pre>
getSettingsGtkImModule :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-im-module</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkImModule <a>:=</a> value ]
--   </pre>
setSettingsGtkImModule :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-im-module</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSettingsGtkImModule :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-im-module</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkImModule
--   </pre>
clearSettingsGtkImModule :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-im-preedit-style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkImPreeditStyle
--   </pre>
getSettingsGtkImPreeditStyle :: (MonadIO m, IsSettings o) => o -> m IMPreeditStyle

-- | Set the value of the “<tt>gtk-im-preedit-style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkImPreeditStyle <a>:=</a> value ]
--   </pre>
setSettingsGtkImPreeditStyle :: (MonadIO m, IsSettings o) => o -> IMPreeditStyle -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-im-preedit-style</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkImPreeditStyle :: (IsSettings o, MonadIO m) => IMPreeditStyle -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-im-status-style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkImStatusStyle
--   </pre>
getSettingsGtkImStatusStyle :: (MonadIO m, IsSettings o) => o -> m IMStatusStyle

-- | Set the value of the “<tt>gtk-im-status-style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkImStatusStyle <a>:=</a> value ]
--   </pre>
setSettingsGtkImStatusStyle :: (MonadIO m, IsSettings o) => o -> IMStatusStyle -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-im-status-style</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkImStatusStyle :: (IsSettings o, MonadIO m) => IMStatusStyle -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-key-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkKeyThemeName
--   </pre>
getSettingsGtkKeyThemeName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-key-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkKeyThemeName <a>:=</a> value ]
--   </pre>
setSettingsGtkKeyThemeName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-key-theme-name</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkKeyThemeName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-key-theme-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkKeyThemeName
--   </pre>
clearSettingsGtkKeyThemeName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-keynav-cursor-only</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkKeynavCursorOnly
--   </pre>
getSettingsGtkKeynavCursorOnly :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-keynav-cursor-only</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkKeynavCursorOnly <a>:=</a> value ]
--   </pre>
setSettingsGtkKeynavCursorOnly :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-keynav-cursor-only</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkKeynavCursorOnly :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-keynav-use-caret</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkKeynavUseCaret
--   </pre>
getSettingsGtkKeynavUseCaret :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-keynav-use-caret</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkKeynavUseCaret <a>:=</a> value ]
--   </pre>
setSettingsGtkKeynavUseCaret :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-keynav-use-caret</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkKeynavUseCaret :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-keynav-wrap-around</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkKeynavWrapAround
--   </pre>
getSettingsGtkKeynavWrapAround :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-keynav-wrap-around</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkKeynavWrapAround <a>:=</a> value ]
--   </pre>
setSettingsGtkKeynavWrapAround :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-keynav-wrap-around</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkKeynavWrapAround :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-label-select-on-focus</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkLabelSelectOnFocus
--   </pre>
getSettingsGtkLabelSelectOnFocus :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-label-select-on-focus</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkLabelSelectOnFocus <a>:=</a> value ]
--   </pre>
setSettingsGtkLabelSelectOnFocus :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-label-select-on-focus</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkLabelSelectOnFocus :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-long-press-time</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkLongPressTime
--   </pre>
getSettingsGtkLongPressTime :: (MonadIO m, IsSettings o) => o -> m Word32

-- | Set the value of the “<tt>gtk-long-press-time</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkLongPressTime <a>:=</a> value ]
--   </pre>
setSettingsGtkLongPressTime :: (MonadIO m, IsSettings o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-long-press-time</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkLongPressTime :: (IsSettings o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-menu-bar-accel</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkMenuBarAccel
--   </pre>
getSettingsGtkMenuBarAccel :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-menu-bar-accel</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkMenuBarAccel <a>:=</a> value ]
--   </pre>
setSettingsGtkMenuBarAccel :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-menu-bar-accel</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkMenuBarAccel :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-menu-bar-accel</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkMenuBarAccel
--   </pre>
clearSettingsGtkMenuBarAccel :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-menu-bar-popup-delay</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkMenuBarPopupDelay
--   </pre>
getSettingsGtkMenuBarPopupDelay :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-menu-bar-popup-delay</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkMenuBarPopupDelay <a>:=</a> value ]
--   </pre>
setSettingsGtkMenuBarPopupDelay :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-menu-bar-popup-delay</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkMenuBarPopupDelay :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-menu-images</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkMenuImages
--   </pre>
getSettingsGtkMenuImages :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-menu-images</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkMenuImages <a>:=</a> value ]
--   </pre>
setSettingsGtkMenuImages :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-menu-images</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkMenuImages :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-menu-popdown-delay</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkMenuPopdownDelay
--   </pre>
getSettingsGtkMenuPopdownDelay :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-menu-popdown-delay</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkMenuPopdownDelay <a>:=</a> value ]
--   </pre>
setSettingsGtkMenuPopdownDelay :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-menu-popdown-delay</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkMenuPopdownDelay :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-menu-popup-delay</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkMenuPopupDelay
--   </pre>
getSettingsGtkMenuPopupDelay :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-menu-popup-delay</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkMenuPopupDelay <a>:=</a> value ]
--   </pre>
setSettingsGtkMenuPopupDelay :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-menu-popup-delay</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkMenuPopupDelay :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-modules</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkModules
--   </pre>
getSettingsGtkModules :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-modules</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkModules <a>:=</a> value ]
--   </pre>
setSettingsGtkModules :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-modules</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSettingsGtkModules :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-modules</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkModules
--   </pre>
clearSettingsGtkModules :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-overlay-scrolling</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkOverlayScrolling
--   </pre>
getSettingsGtkOverlayScrolling :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-overlay-scrolling</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkOverlayScrolling <a>:=</a> value ]
--   </pre>
setSettingsGtkOverlayScrolling :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-overlay-scrolling</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkOverlayScrolling :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-primary-button-warps-slider</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkPrimaryButtonWarpsSlider
--   </pre>
getSettingsGtkPrimaryButtonWarpsSlider :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-primary-button-warps-slider</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkPrimaryButtonWarpsSlider <a>:=</a> value ]
--   </pre>
setSettingsGtkPrimaryButtonWarpsSlider :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-primary-button-warps-slider</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructSettingsGtkPrimaryButtonWarpsSlider :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-print-backends</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkPrintBackends
--   </pre>
getSettingsGtkPrintBackends :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-print-backends</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkPrintBackends <a>:=</a> value ]
--   </pre>
setSettingsGtkPrintBackends :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-print-backends</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkPrintBackends :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-print-backends</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkPrintBackends
--   </pre>
clearSettingsGtkPrintBackends :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-print-preview-command</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkPrintPreviewCommand
--   </pre>
getSettingsGtkPrintPreviewCommand :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-print-preview-command</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkPrintPreviewCommand <a>:=</a> value ]
--   </pre>
setSettingsGtkPrintPreviewCommand :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-print-preview-command</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkPrintPreviewCommand :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-print-preview-command</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkPrintPreviewCommand
--   </pre>
clearSettingsGtkPrintPreviewCommand :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-recent-files-enabled</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkRecentFilesEnabled
--   </pre>
getSettingsGtkRecentFilesEnabled :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-recent-files-enabled</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkRecentFilesEnabled <a>:=</a> value ]
--   </pre>
setSettingsGtkRecentFilesEnabled :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-recent-files-enabled</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkRecentFilesEnabled :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-recent-files-limit</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkRecentFilesLimit
--   </pre>
getSettingsGtkRecentFilesLimit :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-recent-files-limit</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkRecentFilesLimit <a>:=</a> value ]
--   </pre>
setSettingsGtkRecentFilesLimit :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-recent-files-limit</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkRecentFilesLimit :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-recent-files-max-age</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkRecentFilesMaxAge
--   </pre>
getSettingsGtkRecentFilesMaxAge :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-recent-files-max-age</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkRecentFilesMaxAge <a>:=</a> value ]
--   </pre>
setSettingsGtkRecentFilesMaxAge :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-recent-files-max-age</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkRecentFilesMaxAge :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-scrolled-window-placement</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkScrolledWindowPlacement
--   </pre>
getSettingsGtkScrolledWindowPlacement :: (MonadIO m, IsSettings o) => o -> m CornerType

-- | Set the value of the “<tt>gtk-scrolled-window-placement</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkScrolledWindowPlacement <a>:=</a> value ]
--   </pre>
setSettingsGtkScrolledWindowPlacement :: (MonadIO m, IsSettings o) => o -> CornerType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-scrolled-window-placement</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructSettingsGtkScrolledWindowPlacement :: (IsSettings o, MonadIO m) => CornerType -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-shell-shows-app-menu</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkShellShowsAppMenu
--   </pre>
getSettingsGtkShellShowsAppMenu :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-shell-shows-app-menu</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkShellShowsAppMenu <a>:=</a> value ]
--   </pre>
setSettingsGtkShellShowsAppMenu :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-shell-shows-app-menu</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkShellShowsAppMenu :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-shell-shows-desktop</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkShellShowsDesktop
--   </pre>
getSettingsGtkShellShowsDesktop :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-shell-shows-desktop</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkShellShowsDesktop <a>:=</a> value ]
--   </pre>
setSettingsGtkShellShowsDesktop :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-shell-shows-desktop</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkShellShowsDesktop :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-shell-shows-menubar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkShellShowsMenubar
--   </pre>
getSettingsGtkShellShowsMenubar :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-shell-shows-menubar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkShellShowsMenubar <a>:=</a> value ]
--   </pre>
setSettingsGtkShellShowsMenubar :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-shell-shows-menubar</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkShellShowsMenubar :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-show-input-method-menu</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkShowInputMethodMenu
--   </pre>
getSettingsGtkShowInputMethodMenu :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-show-input-method-menu</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkShowInputMethodMenu <a>:=</a> value ]
--   </pre>
setSettingsGtkShowInputMethodMenu :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-show-input-method-menu</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkShowInputMethodMenu :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-show-unicode-menu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkShowUnicodeMenu
--   </pre>
getSettingsGtkShowUnicodeMenu :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-show-unicode-menu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkShowUnicodeMenu <a>:=</a> value ]
--   </pre>
setSettingsGtkShowUnicodeMenu :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-show-unicode-menu</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkShowUnicodeMenu :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-sound-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkSoundThemeName
--   </pre>
getSettingsGtkSoundThemeName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-sound-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkSoundThemeName <a>:=</a> value ]
--   </pre>
setSettingsGtkSoundThemeName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-sound-theme-name</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkSoundThemeName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-sound-theme-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkSoundThemeName
--   </pre>
clearSettingsGtkSoundThemeName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-split-cursor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkSplitCursor
--   </pre>
getSettingsGtkSplitCursor :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-split-cursor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkSplitCursor <a>:=</a> value ]
--   </pre>
setSettingsGtkSplitCursor :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-split-cursor</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkSplitCursor :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkThemeName
--   </pre>
getSettingsGtkThemeName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkThemeName <a>:=</a> value ]
--   </pre>
setSettingsGtkThemeName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-theme-name</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkThemeName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-theme-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkThemeName
--   </pre>
clearSettingsGtkThemeName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-timeout-expand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkTimeoutExpand
--   </pre>
getSettingsGtkTimeoutExpand :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-timeout-expand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkTimeoutExpand <a>:=</a> value ]
--   </pre>
setSettingsGtkTimeoutExpand :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-timeout-expand</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkTimeoutExpand :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-timeout-initial</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkTimeoutInitial
--   </pre>
getSettingsGtkTimeoutInitial :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-timeout-initial</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkTimeoutInitial <a>:=</a> value ]
--   </pre>
setSettingsGtkTimeoutInitial :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-timeout-initial</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkTimeoutInitial :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-timeout-repeat</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkTimeoutRepeat
--   </pre>
getSettingsGtkTimeoutRepeat :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-timeout-repeat</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkTimeoutRepeat <a>:=</a> value ]
--   </pre>
setSettingsGtkTimeoutRepeat :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-timeout-repeat</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkTimeoutRepeat :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-titlebar-double-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkTitlebarDoubleClick
--   </pre>
getSettingsGtkTitlebarDoubleClick :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-titlebar-double-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkTitlebarDoubleClick <a>:=</a> value ]
--   </pre>
setSettingsGtkTitlebarDoubleClick :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-titlebar-double-click</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkTitlebarDoubleClick :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-titlebar-double-click</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkTitlebarDoubleClick
--   </pre>
clearSettingsGtkTitlebarDoubleClick :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-titlebar-middle-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkTitlebarMiddleClick
--   </pre>
getSettingsGtkTitlebarMiddleClick :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-titlebar-middle-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkTitlebarMiddleClick <a>:=</a> value ]
--   </pre>
setSettingsGtkTitlebarMiddleClick :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-titlebar-middle-click</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkTitlebarMiddleClick :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-titlebar-middle-click</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkTitlebarMiddleClick
--   </pre>
clearSettingsGtkTitlebarMiddleClick :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-titlebar-right-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkTitlebarRightClick
--   </pre>
getSettingsGtkTitlebarRightClick :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-titlebar-right-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkTitlebarRightClick <a>:=</a> value ]
--   </pre>
setSettingsGtkTitlebarRightClick :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-titlebar-right-click</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkTitlebarRightClick :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-titlebar-right-click</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkTitlebarRightClick
--   </pre>
clearSettingsGtkTitlebarRightClick :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-toolbar-icon-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkToolbarIconSize
--   </pre>
getSettingsGtkToolbarIconSize :: (MonadIO m, IsSettings o) => o -> m IconSize

-- | Set the value of the “<tt>gtk-toolbar-icon-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkToolbarIconSize <a>:=</a> value ]
--   </pre>
setSettingsGtkToolbarIconSize :: (MonadIO m, IsSettings o) => o -> IconSize -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-toolbar-icon-size</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkToolbarIconSize :: (IsSettings o, MonadIO m) => IconSize -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-toolbar-style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkToolbarStyle
--   </pre>
getSettingsGtkToolbarStyle :: (MonadIO m, IsSettings o) => o -> m ToolbarStyle

-- | Set the value of the “<tt>gtk-toolbar-style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkToolbarStyle <a>:=</a> value ]
--   </pre>
setSettingsGtkToolbarStyle :: (MonadIO m, IsSettings o) => o -> ToolbarStyle -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-toolbar-style</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkToolbarStyle :: (IsSettings o, MonadIO m) => ToolbarStyle -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-tooltip-browse-mode-timeout</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkTooltipBrowseModeTimeout
--   </pre>
getSettingsGtkTooltipBrowseModeTimeout :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-tooltip-browse-mode-timeout</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkTooltipBrowseModeTimeout <a>:=</a> value ]
--   </pre>
setSettingsGtkTooltipBrowseModeTimeout :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-tooltip-browse-mode-timeout</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructSettingsGtkTooltipBrowseModeTimeout :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-tooltip-browse-timeout</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkTooltipBrowseTimeout
--   </pre>
getSettingsGtkTooltipBrowseTimeout :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-tooltip-browse-timeout</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkTooltipBrowseTimeout <a>:=</a> value ]
--   </pre>
setSettingsGtkTooltipBrowseTimeout :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-tooltip-browse-timeout</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkTooltipBrowseTimeout :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-tooltip-timeout</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkTooltipTimeout
--   </pre>
getSettingsGtkTooltipTimeout :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-tooltip-timeout</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkTooltipTimeout <a>:=</a> value ]
--   </pre>
setSettingsGtkTooltipTimeout :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-tooltip-timeout</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkTooltipTimeout :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-touchscreen-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkTouchscreenMode
--   </pre>
getSettingsGtkTouchscreenMode :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-touchscreen-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkTouchscreenMode <a>:=</a> value ]
--   </pre>
setSettingsGtkTouchscreenMode :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-touchscreen-mode</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkTouchscreenMode :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-visible-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkVisibleFocus
--   </pre>
getSettingsGtkVisibleFocus :: (MonadIO m, IsSettings o) => o -> m PolicyType

-- | Set the value of the “<tt>gtk-visible-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkVisibleFocus <a>:=</a> value ]
--   </pre>
setSettingsGtkVisibleFocus :: (MonadIO m, IsSettings o) => o -> PolicyType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-visible-focus</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkVisibleFocus :: (IsSettings o, MonadIO m) => PolicyType -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-xft-antialias</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkXftAntialias
--   </pre>
getSettingsGtkXftAntialias :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-xft-antialias</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkXftAntialias <a>:=</a> value ]
--   </pre>
setSettingsGtkXftAntialias :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-xft-antialias</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkXftAntialias :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-xft-dpi</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkXftDpi
--   </pre>
getSettingsGtkXftDpi :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-xft-dpi</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkXftDpi <a>:=</a> value ]
--   </pre>
setSettingsGtkXftDpi :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-xft-dpi</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSettingsGtkXftDpi :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-xft-hinting</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkXftHinting
--   </pre>
getSettingsGtkXftHinting :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-xft-hinting</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkXftHinting <a>:=</a> value ]
--   </pre>
setSettingsGtkXftHinting :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-xft-hinting</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkXftHinting :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-xft-hintstyle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkXftHintstyle
--   </pre>
getSettingsGtkXftHintstyle :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-xft-hintstyle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkXftHintstyle <a>:=</a> value ]
--   </pre>
setSettingsGtkXftHintstyle :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-xft-hintstyle</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkXftHintstyle :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-xft-hintstyle</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkXftHintstyle
--   </pre>
clearSettingsGtkXftHintstyle :: (MonadIO m, IsSettings o) => o -> m ()

-- | Get the value of the “<tt>gtk-xft-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkXftRgba
--   </pre>
getSettingsGtkXftRgba :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-xft-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkXftRgba <a>:=</a> value ]
--   </pre>
setSettingsGtkXftRgba :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-xft-rgba</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSettingsGtkXftRgba :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>gtk-xft-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkXftRgba
--   </pre>
clearSettingsGtkXftRgba :: (MonadIO m, IsSettings o) => o -> m ()

-- | Undoes the effect of calling <tt><i>g_object_set()</i></tt> to install
--   an application-specific value for a setting. After this call, the
--   setting will again follow the session-wide value for this setting.
--   
--   <i>Since: 3.20</i>
settingsResetProperty :: (HasCallStack, MonadIO m, IsSettings a) => a -> Text -> m ()

-- | <i>No description available in the introspection data.</i>
settingsSetDoubleProperty :: (HasCallStack, MonadIO m, IsSettings a) => a -> Text -> Double -> Text -> m ()

-- | <i>No description available in the introspection data.</i>
settingsSetLongProperty :: (HasCallStack, MonadIO m, IsSettings a) => a -> Text -> CLong -> Text -> m ()

-- | <i>No description available in the introspection data.</i>
settingsSetPropertyValue :: (HasCallStack, MonadIO m, IsSettings a) => a -> Text -> SettingsValue -> m ()

-- | <i>No description available in the introspection data.</i>
settingsSetStringProperty :: (HasCallStack, MonadIO m, IsSettings a) => a -> Text -> Text -> Text -> m ()

-- | Gets the <a>Settings</a> object for the default GDK screen, creating
--   it if necessary. See <a>settingsGetForScreen</a>.
settingsGetDefault :: (HasCallStack, MonadIO m) => m (Maybe Settings)

-- | <i>No description available in the introspection data.</i>
settingsInstallProperty :: (HasCallStack, MonadIO m) => GParamSpec -> m ()

-- | Creates a new <a>IconFactory</a>. An icon factory manages a collection
--   of <tt><i>GtkIconSets</i></tt>; a <a>IconSet</a> manages a set of
--   variants of a particular icon (i.e. a <a>IconSet</a> contains variants
--   for different sizes and widget states). Icons in an icon factory are
--   named by a stock ID, which is a simple string identifying the icon.
--   Each <a>Style</a> has a list of <tt><i>GtkIconFactorys</i></tt>
--   derived from the current theme; those icon factories are consulted
--   first when searching for an icon. If the theme doesn’t set a
--   particular icon, GTK+ looks for the icon in a list of default icon
--   factories, maintained by <a>iconFactoryAddDefault</a> and
--   <a>iconFactoryRemoveDefault</a>. Applications with icons should add a
--   default icon factory with their icons, which will allow themes to
--   override the icons for the application.
iconFactoryNew :: (HasCallStack, MonadIO m) => m IconFactory

-- | Looks up <i><tt>stockId</tt></i> in the icon factory, returning an
--   icon set if found, otherwise <a>Nothing</a>. For display to the user,
--   you should use <a>styleLookupIconSet</a> on the <a>Style</a> for the
--   widget that will display the icon, instead of using this function
--   directly, so that themes are taken into account.
iconFactoryLookup :: (HasCallStack, MonadIO m, IsIconFactory a) => a -> Text -> m IconSet

-- | Removes an icon factory from the list of default icon factories. Not
--   normally used; you might use it for a library that can be unloaded or
--   shut down.
iconFactoryRemoveDefault :: (HasCallStack, MonadIO m, IsIconFactory a) => a -> m ()

-- | Looks for an icon in the list of default icon factories. For display
--   to the user, you should use <a>styleLookupIconSet</a> on the
--   <a>Style</a> for the widget that will display the icon, instead of
--   using this function directly, so that themes are taken into account.
iconFactoryLookupDefault :: (HasCallStack, MonadIO m) => Text -> m IconSet

-- | Connect a signal handler for the <a>add</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> container #add callback
--   </pre>
onContainerAdd :: (IsContainer a, MonadIO m) => a -> ((?self :: a) => ContainerAddCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>add</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> container #add callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterContainerAdd :: (IsContainer a, MonadIO m) => a -> ((?self :: a) => ContainerAddCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>checkResize</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> container #checkResize callback
--   </pre>
onContainerCheckResize :: (IsContainer a, MonadIO m) => a -> ((?self :: a) => ContainerCheckResizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>checkResize</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> container #checkResize callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterContainerCheckResize :: (IsContainer a, MonadIO m) => a -> ((?self :: a) => ContainerCheckResizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>remove</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> container #remove callback
--   </pre>
onContainerRemove :: (IsContainer a, MonadIO m) => a -> ((?self :: a) => ContainerRemoveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>remove</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> container #remove callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterContainerRemove :: (IsContainer a, MonadIO m) => a -> ((?self :: a) => ContainerRemoveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>setFocusChild</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> container #setFocusChild callback
--   </pre>
onContainerSetFocusChild :: (IsContainer a, MonadIO m) => a -> ((?self :: a) => ContainerSetFocusChildCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>setFocusChild</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> container #setFocusChild callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterContainerSetFocusChild :: (IsContainer a, MonadIO m) => a -> ((?self :: a) => ContainerSetFocusChildCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>border-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> container #borderWidth
--   </pre>
getContainerBorderWidth :: (MonadIO m, IsContainer o) => o -> m Word32

-- | Set the value of the “<tt>border-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> container [ #borderWidth <a>:=</a> value ]
--   </pre>
setContainerBorderWidth :: (MonadIO m, IsContainer o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>border-width</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructContainerBorderWidth :: (IsContainer o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> container [ #child <a>:=</a> value ]
--   </pre>
setContainerChild :: (MonadIO m, IsContainer o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructContainerChild :: (IsContainer o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearContainerChild :: (MonadIO m, IsContainer o) => o -> m ()

-- | Get the value of the “<tt>resize-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> container #resizeMode
--   </pre>
getContainerResizeMode :: (MonadIO m, IsContainer o) => o -> m ResizeMode

-- | Set the value of the “<tt>resize-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> container [ #resizeMode <a>:=</a> value ]
--   </pre>
setContainerResizeMode :: (MonadIO m, IsContainer o) => o -> ResizeMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>resize-mode</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructContainerResizeMode :: (IsContainer o, MonadIO m) => ResizeMode -> m (GValueConstruct o)

-- | <i>No description available in the introspection data.</i>
containerCheckResize :: (HasCallStack, MonadIO m, IsContainer a) => a -> m ()

-- | Gets the value of a child property for <i><tt>child</tt></i> and
--   <i><tt>container</tt></i>.
containerChildGetProperty :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> b -> Text -> GValue -> m ()

-- | Emits a <a>Widget::childNotify</a> signal for the [child
--   property][child-properties] specified by <i><tt>pspec</tt></i> on the
--   child.
--   
--   This is an analogue of <a>objectNotifyByPspec</a> for child
--   properties.
--   
--   <i>Since: 3.18</i>
containerChildNotifyByPspec :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> b -> GParamSpec -> m ()

-- | Sets a child property for <i><tt>child</tt></i> and
--   <i><tt>container</tt></i>.
containerChildSetProperty :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> b -> Text -> GValue -> m ()

-- | Returns the type of the children supported by the container.
--   
--   Note that this may return <tt><i>G_TYPE_NONE</i></tt> to indicate that
--   no more children can be added, e.g. for a <a>Paned</a> which already
--   has two children.
containerChildType :: (HasCallStack, MonadIO m, IsContainer a) => a -> m GType

-- | Retrieves the border width of the container. See
--   <a>containerSetBorderWidth</a>.
containerGetBorderWidth :: (HasCallStack, MonadIO m, IsContainer a) => a -> m Word32

-- | Returns the container’s non-internal children. See
--   <a>containerForall</a> for details on what constitutes an "internal"
--   child.
containerGetChildren :: (HasCallStack, MonadIO m, IsContainer a) => a -> m [Widget]

-- | Retrieves the focus chain of the container, if one has been set
--   explicitly. If no focus chain has been explicitly set, GTK+ computes
--   the focus chain based on the positions of the children. In that case,
--   GTK+ stores <a>Nothing</a> in <i><tt>focusableWidgets</tt></i> and
--   returns <a>False</a>.
containerGetFocusChain :: (HasCallStack, MonadIO m, IsContainer a) => a -> m (Bool, [Widget])

-- | Returns the current focus child widget inside
--   <i><tt>container</tt></i>. This is not the currently focused widget.
--   That can be obtained by calling <a>windowGetFocus</a>.
--   
--   <i>Since: 2.14</i>
containerGetFocusChild :: (HasCallStack, MonadIO m, IsContainer a) => a -> m (Maybe Widget)

-- | Retrieves the horizontal focus adjustment for the container. See
--   gtk_container_set_focus_hadjustment ().
containerGetFocusHadjustment :: (HasCallStack, MonadIO m, IsContainer a) => a -> m (Maybe Adjustment)

-- | Retrieves the vertical focus adjustment for the container. See
--   <a>containerSetFocusVadjustment</a>.
containerGetFocusVadjustment :: (HasCallStack, MonadIO m, IsContainer a) => a -> m (Maybe Adjustment)

-- | Returns the resize mode for the container. See
--   gtk_container_set_resize_mode ().
containerGetResizeMode :: (HasCallStack, MonadIO m, IsContainer a) => a -> m ResizeMode

-- | <i>No description available in the introspection data.</i>
containerResizeChildren :: (HasCallStack, MonadIO m, IsContainer a) => a -> m ()

-- | Sets the border width of the container.
--   
--   The border width of a container is the amount of space to leave around
--   the outside of the container. The only exception to this is
--   <a>Window</a>; because toplevel windows can’t leave space outside,
--   they leave the space inside. The border is added on all sides of the
--   container. To add space to only one side, use a specific
--   <a>Widget:margin</a> property on the child widget, for example
--   <a>Widget:marginTop</a>.
containerSetBorderWidth :: (HasCallStack, MonadIO m, IsContainer a) => a -> Word32 -> m ()

-- | Sets, or unsets if <i><tt>child</tt></i> is <a>Nothing</a>, the
--   focused child of <i><tt>container</tt></i>.
--   
--   This function emits the GtkContainer<a>set_focus_child</a> signal of
--   <i><tt>container</tt></i>. Implementations of <a>Container</a> can
--   override the default behaviour by overriding the class closure of this
--   signal.
--   
--   This is function is mostly meant to be used by widgets. Applications
--   can use <a>widgetGrabFocus</a> to manually set the focus to a specific
--   widget.
containerSetFocusChild :: (HasCallStack, MonadIO m, IsContainer a, IsWidget b) => a -> Maybe b -> m ()

-- | Hooks up an adjustment to focus handling in a container, so when a
--   child of the container is focused, the adjustment is scrolled to show
--   that widget. This function sets the horizontal alignment. See
--   <a>scrolledWindowGetHadjustment</a> for a typical way of obtaining the
--   adjustment and <a>containerSetFocusVadjustment</a> for setting the
--   vertical adjustment.
--   
--   The adjustments have to be in pixel units and in the same coordinate
--   system as the allocation for immediate children of the container.
containerSetFocusHadjustment :: (HasCallStack, MonadIO m, IsContainer a, IsAdjustment b) => a -> b -> m ()

-- | Hooks up an adjustment to focus handling in a container, so when a
--   child of the container is focused, the adjustment is scrolled to show
--   that widget. This function sets the vertical alignment. See
--   <a>scrolledWindowGetVadjustment</a> for a typical way of obtaining the
--   adjustment and <a>containerSetFocusHadjustment</a> for setting the
--   horizontal adjustment.
--   
--   The adjustments have to be in pixel units and in the same coordinate
--   system as the allocation for immediate children of the container.
containerSetFocusVadjustment :: (HasCallStack, MonadIO m, IsContainer a, IsAdjustment b) => a -> b -> m ()

-- | Sets the <i><tt>reallocateRedraws</tt></i> flag of the container to
--   the given value.
--   
--   Containers requesting reallocation redraws get automatically redrawn
--   if any of their children changed allocation.
containerSetReallocateRedraws :: (HasCallStack, MonadIO m, IsContainer a) => a -> Bool -> m ()

-- | Sets the resize mode for the container.
--   
--   The resize mode of a container determines whether a resize request
--   will be passed to the container’s parent, queued for later execution
--   or executed immediately.
containerSetResizeMode :: (HasCallStack, MonadIO m, IsContainer a) => a -> ResizeMode -> m ()

-- | Removes a focus chain explicitly set with
--   <a>containerSetFocusChain</a>.
containerUnsetFocusChain :: (HasCallStack, MonadIO m, IsContainer a) => a -> m ()

-- | Connect a signal handler for the <a>ownerChange</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> clipboard #ownerChange callback
--   </pre>
onClipboardOwnerChange :: (IsClipboard a, MonadIO m) => a -> ((?self :: a) => ClipboardOwnerChangeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>ownerChange</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> clipboard #ownerChange callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterClipboardOwnerChange :: (IsClipboard a, MonadIO m) => a -> ((?self :: a) => ClipboardOwnerChangeCallback) -> m SignalHandlerId

-- | Clears the contents of the clipboard. Generally this should only be
--   called between the time you call
--   <tt><i>gtk_clipboard_set_with_owner()</i></tt> or
--   <tt><i>gtk_clipboard_set_with_data()</i></tt>, and when the
--   <i><tt>clearFunc</tt></i> you supplied is called. Otherwise, the
--   clipboard may be owned by someone else.
clipboardClear :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m ()

-- | Gets the <a>Display</a> associated with <i><tt>clipboard</tt></i>
--   
--   <i>Since: 2.2</i>
clipboardGetDisplay :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m Display

-- | If the clipboard contents callbacks were set with
--   <tt><i>gtk_clipboard_set_with_owner()</i></tt>, and the
--   <tt><i>gtk_clipboard_set_with_data()</i></tt> or <a>clipboardClear</a>
--   has not subsequently called, returns the owner set by
--   <tt><i>gtk_clipboard_set_with_owner()</i></tt>.
clipboardGetOwner :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m (Maybe Object)

-- | Gets the selection that this clipboard is for.
--   
--   <i>Since: 3.22</i>
clipboardGetSelection :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m Atom

-- | Hints that the clipboard data should be stored somewhere when the
--   application exits or when gtk_clipboard_store () is called.
--   
--   This value is reset when the clipboard owner changes. Where the
--   clipboard data is stored is platform dependent, see
--   gdk_display_store_clipboard () for more information.
--   
--   <i>Since: 2.6</i>
clipboardSetCanStore :: (HasCallStack, MonadIO m, IsClipboard a) => a -> Maybe [TargetEntry] -> m ()

-- | Sets the contents of the clipboard to the given <a>Pixbuf</a>. GTK+
--   will take responsibility for responding for requests for the image,
--   and for converting the image into the requested format.
--   
--   <i>Since: 2.6</i>
clipboardSetImage :: (HasCallStack, MonadIO m, IsClipboard a, IsPixbuf b) => a -> b -> m ()

-- | Sets the contents of the clipboard to the given UTF-8 string. GTK+
--   will make a copy of the text and take responsibility for responding
--   for requests for the text, and for converting the text into the
--   requested format.
clipboardSetText :: (HasCallStack, MonadIO m, IsClipboard a) => a -> Text -> Int32 -> m ()

-- | Stores the current clipboard data somewhere so that it will stay
--   around after the application has quit.
--   
--   <i>Since: 2.6</i>
clipboardStore :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m ()

-- | Requests the contents of the clipboard using the given target. This
--   function waits for the data to be received using the main loop, so
--   events, timeouts, etc, may be dispatched during the wait.
clipboardWaitForContents :: (HasCallStack, MonadIO m, IsClipboard a) => a -> Atom -> m (Maybe SelectionData)

-- | Requests the contents of the clipboard as image and converts the
--   result to a <a>Pixbuf</a>. This function waits for the data to be
--   received using the main loop, so events, timeouts, etc, may be
--   dispatched during the wait.
--   
--   <i>Since: 2.6</i>
clipboardWaitForImage :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m (Maybe Pixbuf)

-- | Returns a list of targets that are present on the clipboard, or
--   <a>Nothing</a> if there aren’t any targets available. The returned
--   list must be freed with <a>free</a>. This function waits for the data
--   to be received using the main loop, so events, timeouts, etc, may be
--   dispatched during the wait.
--   
--   <i>Since: 2.4</i>
clipboardWaitForTargets :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m (Bool, [Atom])

-- | Requests the contents of the clipboard as text and converts the result
--   to UTF-8 if necessary. This function waits for the data to be received
--   using the main loop, so events, timeouts, etc, may be dispatched
--   during the wait.
clipboardWaitForText :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m (Maybe Text)

-- | Requests the contents of the clipboard as URIs. This function waits
--   for the data to be received using the main loop, so events, timeouts,
--   etc, may be dispatched during the wait.
--   
--   <i>Since: 2.14</i>
clipboardWaitForUris :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m (Maybe [Text])

-- | Test to see if there is an image available to be pasted This is done
--   by requesting the TARGETS atom and checking if it contains any of the
--   supported image targets. This function waits for the data to be
--   received using the main loop, so events, timeouts, etc, may be
--   dispatched during the wait.
--   
--   This function is a little faster than calling
--   <a>clipboardWaitForImage</a> since it doesn’t need to retrieve the
--   actual image data.
--   
--   <i>Since: 2.6</i>
clipboardWaitIsImageAvailable :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m Bool

-- | Test to see if there is rich text available to be pasted This is done
--   by requesting the TARGETS atom and checking if it contains any of the
--   supported rich text targets. This function waits for the data to be
--   received using the main loop, so events, timeouts, etc, may be
--   dispatched during the wait.
--   
--   This function is a little faster than calling
--   <a>clipboardWaitForRichText</a> since it doesn’t need to retrieve the
--   actual text.
--   
--   <i>Since: 2.10</i>
clipboardWaitIsRichTextAvailable :: (HasCallStack, MonadIO m, IsClipboard a, IsTextBuffer b) => a -> b -> m Bool

-- | Checks if a clipboard supports pasting data of a given type. This
--   function can be used to determine if a “Paste” menu item should be
--   insensitive or not.
--   
--   If you want to see if there’s text available on the clipboard, use
--   gtk_clipboard_wait_is_text_available () instead.
--   
--   <i>Since: 2.6</i>
clipboardWaitIsTargetAvailable :: (HasCallStack, MonadIO m, IsClipboard a) => a -> Atom -> m Bool

-- | Test to see if there is text available to be pasted This is done by
--   requesting the TARGETS atom and checking if it contains any of the
--   supported text targets. This function waits for the data to be
--   received using the main loop, so events, timeouts, etc, may be
--   dispatched during the wait.
--   
--   This function is a little faster than calling
--   <a>clipboardWaitForText</a> since it doesn’t need to retrieve the
--   actual text.
clipboardWaitIsTextAvailable :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m Bool

-- | Test to see if there is a list of URIs available to be pasted This is
--   done by requesting the TARGETS atom and checking if it contains the
--   URI targets. This function waits for the data to be received using the
--   main loop, so events, timeouts, etc, may be dispatched during the
--   wait.
--   
--   This function is a little faster than calling
--   <a>clipboardWaitForUris</a> since it doesn’t need to retrieve the
--   actual URI data.
--   
--   <i>Since: 2.14</i>
clipboardWaitIsUrisAvailable :: (HasCallStack, MonadIO m, IsClipboard a) => a -> m Bool

-- | Returns the clipboard object for the given selection. See
--   <a>clipboardGetForDisplay</a> for complete details.
clipboardGet :: (HasCallStack, MonadIO m) => Atom -> m Clipboard

-- | Returns the default clipboard object for use with cut/copy/paste menu
--   items and keyboard shortcuts.
--   
--   <i>Since: 3.16</i>
clipboardGetDefault :: (HasCallStack, MonadIO m, IsDisplay a) => a -> m Clipboard

-- | Returns the clipboard object for the given selection. Cut/copy/paste
--   menu items and keyboard shortcuts should use the default clipboard,
--   returned by passing <tt><i>GDK_SELECTION_CLIPBOARD</i></tt> for
--   <i><tt>selection</tt></i>. (<tt><i>GDK_NONE</i></tt> is supported as a
--   synonym for GDK_SELECTION_CLIPBOARD for backwards compatibility
--   reasons.) The currently-selected object or text should be provided on
--   the clipboard identified by <tt><i>GDK_SELECTION_PRIMARY</i></tt>.
--   Cut/copy/paste menu items conceptually copy the contents of the
--   <tt><i>GDK_SELECTION_PRIMARY</i></tt> clipboard to the default
--   clipboard, i.e. they copy the selection to what the user sees as the
--   clipboard.
--   
--   (Passing <tt><i>GDK_NONE</i></tt> is the same as using
--   <tt>gdk_atom_intern ("CLIPBOARD", FALSE)</tt>.
--   
--   See the <a>FreeDesktop Clipboard Specification</a> for a detailed
--   discussion of the “CLIPBOARD” vs. “PRIMARY” selections under the X
--   window system. On Win32 the <tt><i>GDK_SELECTION_PRIMARY</i></tt>
--   clipboard is essentially ignored.)
--   
--   It’s possible to have arbitrary named clipboards; if you do invent new
--   clipboards, you should prefix the selection name with an underscore
--   (because the ICCCM requires that nonstandard atoms are
--   underscore-prefixed), and namespace it as well. For example, if your
--   application called “Foo” has a special-purpose clipboard, you might
--   call it “_FOO_SPECIAL_CLIPBOARD”.
--   
--   <i>Since: 2.2</i>
clipboardGetForDisplay :: (HasCallStack, MonadIO m, IsDisplay a) => a -> Atom -> m Clipboard

-- | Get the value of the “<tt>translation-domain</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> builder #translationDomain
--   </pre>
getBuilderTranslationDomain :: (MonadIO m, IsBuilder o) => o -> m Text

-- | Set the value of the “<tt>translation-domain</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> builder [ #translationDomain <a>:=</a> value ]
--   </pre>
setBuilderTranslationDomain :: (MonadIO m, IsBuilder o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>translation-domain</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructBuilderTranslationDomain :: (IsBuilder o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>translation-domain</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #translationDomain
--   </pre>
clearBuilderTranslationDomain :: (MonadIO m, IsBuilder o) => o -> m ()

-- | Creates a new empty builder object.
--   
--   This function is only useful if you intend to make multiple calls to
--   <a>builderAddFromFile</a>, <a>builderAddFromResource</a> or
--   <a>builderAddFromString</a> in order to merge multiple UI descriptions
--   into a single builder.
--   
--   Most users will probably want to use <a>builderNewFromFile</a>,
--   <a>builderNewFromResource</a> or <a>builderNewFromString</a>.
--   
--   <i>Since: 2.12</i>
builderNew :: (HasCallStack, MonadIO m) => m Builder

-- | Builds the [GtkBuilder UI definition][BUILDER-UI] in the file
--   <i><tt>filename</tt></i>.
--   
--   If there is an error opening the file or parsing the description then
--   the program will be aborted. You should only ever attempt to parse
--   user interface descriptions that are shipped as part of your program.
--   
--   <i>Since: 3.10</i>
builderNewFromFile :: (HasCallStack, MonadIO m) => Text -> m Builder

-- | Builds the [GtkBuilder UI definition][BUILDER-UI] at
--   <i><tt>resourcePath</tt></i>.
--   
--   If there is an error locating the resource or parsing the description,
--   then the program will be aborted.
--   
--   <i>Since: 3.10</i>
builderNewFromResource :: (HasCallStack, MonadIO m) => Text -> m Builder

-- | Builds the user interface described by <i><tt>string</tt></i> (in the
--   [GtkBuilder UI definition][BUILDER-UI] format).
--   
--   If <i><tt>string</tt></i> is <a>Nothing</a>-terminated, then
--   <i><tt>length</tt></i> should be -1. If <i><tt>length</tt></i> is not
--   -1, then it is the length of <i><tt>string</tt></i>.
--   
--   If there is an error parsing <i><tt>string</tt></i> then the program
--   will be aborted. You should not attempt to parse user interface
--   description from untrusted sources.
--   
--   <i>Since: 3.10</i>
builderNewFromString :: (HasCallStack, MonadIO m) => Text -> Int64 -> m Builder

-- | Parses a resource file containing a [GtkBuilder UI
--   definition][BUILDER-UI] and merges it with the current contents of
--   <i><tt>builder</tt></i>.
--   
--   Most users will probably want to use <a>builderNewFromResource</a>.
--   
--   If an error occurs, 0 will be returned and <i><tt>error</tt></i> will
--   be assigned a <a>GError</a> from the
--   <tt><i>GTK_BUILDER_ERROR</i></tt>, <tt><i>G_MARKUP_ERROR</i></tt> or
--   <tt><i>G_RESOURCE_ERROR</i></tt> domain.
--   
--   It’s not really reasonable to attempt to handle failures of this call.
--   The only reasonable thing to do when an error is detected is to call
--   <tt><i>g_error()</i></tt>.
--   
--   <i>Since: 3.4</i>
builderAddFromResource :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> m Word32

-- | Parses a file containing a [GtkBuilder UI definition][BUILDER-UI]
--   building only the requested objects and merges them with the current
--   contents of <i><tt>builder</tt></i>.
--   
--   Upon errors 0 will be returned and <i><tt>error</tt></i> will be
--   assigned a <a>GError</a> from the <tt><i>GTK_BUILDER_ERROR</i></tt>,
--   <tt><i>G_MARKUP_ERROR</i></tt> or <tt><i>G_FILE_ERROR</i></tt> domain.
--   
--   If you are adding an object that depends on an object that is not its
--   child (for instance a <a>TreeView</a> that depends on its
--   <a>TreeModel</a>), you have to explicitly list all of them in
--   <i><tt>objectIds</tt></i>.
--   
--   <i>Since: 2.14</i>
builderAddObjectsFromFile :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> [Text] -> m Word32

-- | Parses a resource file containing a [GtkBuilder UI
--   definition][BUILDER-UI] building only the requested objects and merges
--   them with the current contents of <i><tt>builder</tt></i>.
--   
--   Upon errors 0 will be returned and <i><tt>error</tt></i> will be
--   assigned a <a>GError</a> from the <tt><i>GTK_BUILDER_ERROR</i></tt>,
--   <tt><i>G_MARKUP_ERROR</i></tt> or <tt><i>G_RESOURCE_ERROR</i></tt>
--   domain.
--   
--   If you are adding an object that depends on an object that is not its
--   child (for instance a <a>TreeView</a> that depends on its
--   <a>TreeModel</a>), you have to explicitly list all of them in
--   <i><tt>objectIds</tt></i>.
--   
--   <i>Since: 3.4</i>
builderAddObjectsFromResource :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> [Text] -> m Word32

-- | Parses a string containing a [GtkBuilder UI definition][BUILDER-UI]
--   building only the requested objects and merges them with the current
--   contents of <i><tt>builder</tt></i>.
--   
--   Upon errors 0 will be returned and <i><tt>error</tt></i> will be
--   assigned a <a>GError</a> from the <tt><i>GTK_BUILDER_ERROR</i></tt> or
--   <tt><i>G_MARKUP_ERROR</i></tt> domain.
--   
--   If you are adding an object that depends on an object that is not its
--   child (for instance a <a>TreeView</a> that depends on its
--   <a>TreeModel</a>), you have to explicitly list all of them in
--   <i><tt>objectIds</tt></i>.
--   
--   <i>Since: 2.14</i>
builderAddObjectsFromString :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> CSize -> [Text] -> m Word32

-- | Add <i><tt>object</tt></i> to the <i><tt>builder</tt></i> object pool
--   so it can be referenced just like any other object built by builder.
--   
--   <i>Since: 3.8</i>
builderExposeObject :: (HasCallStack, MonadIO m, IsBuilder a, IsObject b) => a -> Text -> b -> m ()

-- | Main private entry point for building composite container components
--   from template XML.
--   
--   This is exported purely to let gtk-builder-tool validate templates,
--   applications have no need to call this function.
builderExtendWithTemplate :: (HasCallStack, MonadIO m, IsBuilder a, IsWidget b) => a -> b -> GType -> Text -> CSize -> m Word32

-- | Gets the <a>Application</a> associated with the builder.
--   
--   The <a>Application</a> is used for creating action proxies as
--   requested from XML that the builder is loading.
--   
--   By default, the builder uses the default application: the one from
--   <a>applicationGetDefault</a>. If you want to use another application
--   for constructing proxies, use <a>builderSetApplication</a>.
--   
--   <i>Since: 3.10</i>
builderGetApplication :: (HasCallStack, MonadIO m, IsBuilder a) => a -> m (Maybe Application)

-- | Gets the object named <i><tt>name</tt></i>. Note that this function
--   does not increment the reference count of the returned object.
--   
--   <i>Since: 2.12</i>
builderGetObject :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> m (Maybe Object)

-- | Gets all objects that have been constructed by
--   <i><tt>builder</tt></i>. Note that this function does not increment
--   the reference counts of the returned objects.
--   
--   <i>Since: 2.12</i>
builderGetObjects :: (HasCallStack, MonadIO m, IsBuilder a) => a -> m [Object]

-- | Gets the translation domain of <i><tt>builder</tt></i>.
--   
--   <i>Since: 2.12</i>
builderGetTranslationDomain :: (HasCallStack, MonadIO m, IsBuilder a) => a -> m Text

-- | Looks up a type by name, using the virtual function that
--   <a>Builder</a> has for that purpose. This is mainly used when
--   implementing the <a>Buildable</a> interface on a type.
--   
--   <i>Since: 2.12</i>
builderGetTypeFromName :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> m GType

-- | Sets the application associated with <i><tt>builder</tt></i>.
--   
--   You only need this function if there is more than one
--   <a>Application</a> in your process. <i><tt>application</tt></i> cannot
--   be <a>Nothing</a>.
--   
--   <i>Since: 3.10</i>
builderSetApplication :: (HasCallStack, MonadIO m, IsBuilder a, IsApplication b) => a -> b -> m ()

-- | Sets the translation domain of <i><tt>builder</tt></i>. See
--   <a>Builder:translationDomain</a>.
--   
--   <i>Since: 2.12</i>
builderSetTranslationDomain :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Maybe Text -> m ()

-- | This function demarshals a value from a string. This function calls
--   <a>valueInit</a> on the <i><tt>value</tt></i> argument, so it need not
--   be initialised beforehand.
--   
--   This function can handle char, uchar, boolean, int, uint, long, ulong,
--   enum, flags, float, double, string, <a>Color</a>, <a>RGBA</a> and
--   <a>Adjustment</a> type values. Support for <a>Widget</a> type values
--   is still to come.
--   
--   Upon errors <a>False</a> will be returned and <i><tt>error</tt></i>
--   will be assigned a <a>GError</a> from the
--   <tt><i>GTK_BUILDER_ERROR</i></tt> domain.
--   
--   <i>Since: 2.12</i>
builderValueFromString :: (HasCallStack, MonadIO m, IsBuilder a) => a -> GParamSpec -> Text -> m GValue

-- | Like <a>builderValueFromString</a>, this function demarshals a value
--   from a string, but takes a <a>GType</a> instead of <a>ParamSpec</a>.
--   This function calls <a>valueInit</a> on the <i><tt>value</tt></i>
--   argument, so it need not be initialised beforehand.
--   
--   Upon errors <a>False</a> will be returned and <i><tt>error</tt></i>
--   will be assigned a <a>GError</a> from the
--   <tt><i>GTK_BUILDER_ERROR</i></tt> domain.
--   
--   <i>Since: 2.12</i>
builderValueFromStringType :: (HasCallStack, MonadIO m, IsBuilder a) => a -> GType -> Text -> m GValue

-- | Gets the child of the <a>Bin</a>, or <a>Nothing</a> if the bin
--   contains no child widget. The returned widget does not have a
--   reference added, so you do not need to unref it.
binGetChild :: (HasCallStack, MonadIO m, IsBin a) => a -> m (Maybe Widget)

-- | Connect a signal handler for the <a>queryEnd</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> application #queryEnd callback
--   </pre>
onApplicationQueryEnd :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationQueryEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>queryEnd</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> application #queryEnd callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterApplicationQueryEnd :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationQueryEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>windowAdded</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> application #windowAdded callback
--   </pre>
onApplicationWindowAdded :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationWindowAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>windowAdded</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> application #windowAdded callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterApplicationWindowAdded :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationWindowAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>windowRemoved</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> application #windowRemoved callback
--   </pre>
onApplicationWindowRemoved :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationWindowRemovedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>windowRemoved</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> application #windowRemoved callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterApplicationWindowRemoved :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationWindowRemovedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>active-window</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> application #activeWindow
--   </pre>
getApplicationActiveWindow :: (MonadIO m, IsApplication o) => o -> m (Maybe Window)

-- | Get the value of the “<tt>app-menu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> application #appMenu
--   </pre>
getApplicationAppMenu :: (MonadIO m, IsApplication o) => o -> m (Maybe MenuModel)

-- | Set the value of the “<tt>app-menu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> application [ #appMenu <a>:=</a> value ]
--   </pre>
setApplicationAppMenu :: (MonadIO m, IsApplication o, IsMenuModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>app-menu</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructApplicationAppMenu :: (IsApplication o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>app-menu</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #appMenu
--   </pre>
clearApplicationAppMenu :: (MonadIO m, IsApplication o) => o -> m ()

-- | Get the value of the “<tt>menubar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> application #menubar
--   </pre>
getApplicationMenubar :: (MonadIO m, IsApplication o) => o -> m MenuModel

-- | Set the value of the “<tt>menubar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> application [ #menubar <a>:=</a> value ]
--   </pre>
setApplicationMenubar :: (MonadIO m, IsApplication o, IsMenuModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>menubar</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructApplicationMenubar :: (IsApplication o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>menubar</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #menubar
--   </pre>
clearApplicationMenubar :: (MonadIO m, IsApplication o) => o -> m ()

-- | Get the value of the “<tt>register-session</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> application #registerSession
--   </pre>
getApplicationRegisterSession :: (MonadIO m, IsApplication o) => o -> m Bool

-- | Set the value of the “<tt>register-session</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> application [ #registerSession <a>:=</a> value ]
--   </pre>
setApplicationRegisterSession :: (MonadIO m, IsApplication o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>register-session</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructApplicationRegisterSession :: (IsApplication o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>screensaver-active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> application #screensaverActive
--   </pre>
getApplicationScreensaverActive :: (MonadIO m, IsApplication o) => o -> m Bool

-- | Creates a new <a>Application</a> instance.
--   
--   When using <a>Application</a>, it is not necessary to call <a>init</a>
--   manually. It is called as soon as the application gets registered as
--   the primary instance.
--   
--   Concretely, <a>init</a> is called in the default handler for the
--   <a>Application::startup</a> signal. Therefore, <a>Application</a>
--   subclasses should chain up in their <a>Application::startup</a>
--   handler before using any GTK+ API.
--   
--   Note that commandline arguments are not passed to <a>init</a>. All
--   GTK+ functionality that is available via commandline arguments can
--   also be achieved by setting suitable environment variables such as
--   <tt>G_DEBUG</tt>, so this should not be a big problem. If you
--   absolutely must support GTK+ commandline arguments, you can explicitly
--   call <a>init</a> before creating the application instance.
--   
--   If non-<a>Nothing</a>, the application ID must be valid. See
--   <a>applicationIdIsValid</a>.
--   
--   If no application ID is given then some features (most notably
--   application uniqueness) will be disabled. A null application ID is
--   only allowed with GTK+ 3.6 or later.
--   
--   <i>Since: 3.0</i>
applicationNew :: (HasCallStack, MonadIO m) => Maybe Text -> [ApplicationFlags] -> m (Maybe Application)

-- | Installs an accelerator that will cause the named action to be
--   activated when the key combination specificed by
--   <i><tt>accelerator</tt></i> is pressed.
--   
--   <i><tt>accelerator</tt></i> must be a string that can be parsed by
--   <a>acceleratorParse</a>, e.g. "&lt;Primary&gt;q" or
--   “&lt;Control&gt;&lt;Alt&gt;p”.
--   
--   <i><tt>actionName</tt></i> must be the name of an action as it would
--   be used in the app menu, i.e. actions that have been added to the
--   application are referred to with an “app.” prefix, and window-specific
--   actions with a “win.” prefix.
--   
--   GtkApplication also extracts accelerators out of “accel” attributes in
--   the <tt><i>GMenuModels</i></tt> passed to <a>applicationSetAppMenu</a>
--   and <a>applicationSetMenubar</a>, which is usually more convenient
--   than calling this function for each accelerator.
--   
--   <i>Since: 3.4</i>
applicationAddAccelerator :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> Text -> Maybe GVariant -> m ()

-- | Gets the accelerators that are currently associated with the given
--   action.
--   
--   <i>Since: 3.12</i>
applicationGetAccelsForAction :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> m [Text]

-- | Returns the list of actions (possibly empty) that
--   <i><tt>accel</tt></i> maps to. Each item in the list is a detailed
--   action name in the usual form.
--   
--   This might be useful to discover if an accel already exists in order
--   to prevent installation of a conflicting accelerator (from an
--   accelerator editor or a plugin system, for example). Note that having
--   more than one action per accelerator may not be a bad thing and might
--   make sense in cases where the actions never appear in the same
--   context.
--   
--   In case there are no actions for a given accelerator, an empty array
--   is returned. <a>Nothing</a> is never returned.
--   
--   It is a programmer error to pass an invalid accelerator string. If you
--   are unsure, check it with <a>acceleratorParse</a> first.
--   
--   <i>Since: 3.14</i>
applicationGetActionsForAccel :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> m [Text]

-- | Gets the “active” window for the application.
--   
--   The active window is the one that was most recently focused (within
--   the application). This window may not have the focus at the moment if
--   another application has it — this is just the most recently-focused
--   window within this application.
--   
--   <i>Since: 3.6</i>
applicationGetActiveWindow :: (HasCallStack, MonadIO m, IsApplication a) => a -> m (Maybe Window)

-- | Returns the menu model that has been set with
--   <a>applicationSetAppMenu</a>.
--   
--   <i>Since: 3.4</i>
applicationGetAppMenu :: (HasCallStack, MonadIO m, IsApplication a) => a -> m (Maybe MenuModel)

-- | Gets a menu from automatically loaded resources. See [Automatic
--   resources][automatic-resources] for more information.
--   
--   <i>Since: 3.14</i>
applicationGetMenuById :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> m Menu

-- | Returns the menu model that has been set with
--   <a>applicationSetMenubar</a>.
--   
--   <i>Since: 3.4</i>
applicationGetMenubar :: (HasCallStack, MonadIO m, IsApplication a) => a -> m MenuModel

-- | Returns the <a>ApplicationWindow</a> with the given ID.
--   
--   The ID of a <a>ApplicationWindow</a> can be retrieved with
--   <a>applicationWindowGetId</a>.
--   
--   <i>Since: 3.6</i>
applicationGetWindowById :: (HasCallStack, MonadIO m, IsApplication a) => a -> Word32 -> m (Maybe Window)

-- | Gets a list of the <tt><i>GtkWindows</i></tt> associated with
--   <i><tt>application</tt></i>.
--   
--   The list is sorted by most recently focused window, such that the
--   first element is the currently focused window. (Useful for choosing a
--   parent for a transient window.)
--   
--   The list that is returned should not be modified in any way. It will
--   only remain valid until the next focus change or window creation or
--   deletion.
--   
--   <i>Since: 3.0</i>
applicationGetWindows :: (HasCallStack, MonadIO m, IsApplication a) => a -> m [Window]

-- | Determines if any of the actions specified in <i><tt>flags</tt></i>
--   are currently inhibited (possibly by another application).
--   
--   Note that this information may not be available (for example when the
--   application is running in a sandbox).
--   
--   <i>Since: 3.4</i>
applicationIsInhibited :: (HasCallStack, MonadIO m, IsApplication a) => a -> [ApplicationInhibitFlags] -> m Bool

-- | Lists the detailed action names which have associated accelerators.
--   See <a>applicationSetAccelsForAction</a>.
--   
--   <i>Since: 3.12</i>
applicationListActionDescriptions :: (HasCallStack, MonadIO m, IsApplication a) => a -> m [Text]

-- | Determines if the desktop environment in which the application is
--   running would prefer an application menu be shown.
--   
--   If this function returns <a>True</a> then the application should call
--   <a>applicationSetAppMenu</a> with the contents of an application menu,
--   which will be shown by the desktop environment. If it returns
--   <a>False</a> then you should consider using an alternate approach,
--   such as a menubar.
--   
--   The value returned by this function is purely advisory and you are
--   free to ignore it. If you call <a>applicationSetAppMenu</a> even if
--   the desktop environment doesn't support app menus, then a fallback
--   will be provided.
--   
--   Applications are similarly free not to set an app menu even if the
--   desktop environment wants to show one. In that case, a fallback will
--   also be created by the desktop environment (GNOME, for example, uses a
--   menu with only a "Quit" item in it).
--   
--   The value returned by this function never changes. Once it returns a
--   particular value, it is guaranteed to always return the same value.
--   
--   You may only call this function after the application has been
--   registered and after the base startup handler has run. You're most
--   likely to want to use this from your own startup handler. It may also
--   make sense to consult this function while constructing UI (in
--   activate, open or an action activation handler) in order to determine
--   if you should show a gear menu or not.
--   
--   This function will return <a>False</a> on Mac OS and a default app
--   menu will be created automatically with the "usual" contents of that
--   menu typical to most Mac OS applications. If you call
--   <a>applicationSetAppMenu</a> anyway, then this menu will be replaced
--   with your own.
--   
--   <i>Since: 3.14</i>
applicationPrefersAppMenu :: (HasCallStack, MonadIO m, IsApplication a) => a -> m Bool

-- | Removes an accelerator that has been previously added with
--   <a>applicationAddAccelerator</a>.
--   
--   <i>Since: 3.4</i>
applicationRemoveAccelerator :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> Maybe GVariant -> m ()

-- | Sets zero or more keyboard accelerators that will trigger the given
--   action. The first item in <i><tt>accels</tt></i> will be the primary
--   accelerator, which may be displayed in the UI.
--   
--   To remove all accelerators for an action, use an empty,
--   zero-terminated array for <i><tt>accels</tt></i>.
--   
--   For the <i><tt>detailedActionName</tt></i>, see
--   <a>actionParseDetailedName</a> and <a>actionPrintDetailedName</a>.
--   
--   <i>Since: 3.12</i>
applicationSetAccelsForAction :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> [Text] -> m ()

-- | Removes an inhibitor that has been established with
--   <a>applicationInhibit</a>. Inhibitors are also cleared when the
--   application exits.
--   
--   <i>Since: 3.4</i>
applicationUninhibit :: (HasCallStack, MonadIO m, IsApplication a) => a -> Word32 -> m ()

-- | Connect a signal handler for the <a>accelActivate</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> accelGroup #accelActivate callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to “<tt>accel-activate::detail</tt>”
--   instead.
onAccelGroupAccelActivate :: (IsAccelGroup a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AccelGroupAccelActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>accelActivate</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> accelGroup #accelActivate callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to “<tt>accel-activate::detail</tt>”
--   instead.
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAccelGroupAccelActivate :: (IsAccelGroup a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AccelGroupAccelActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>accelChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> accelGroup #accelChanged callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to “<tt>accel-changed::detail</tt>”
--   instead.
onAccelGroupAccelChanged :: (IsAccelGroup a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AccelGroupAccelChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>accelChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> accelGroup #accelChanged callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to “<tt>accel-changed::detail</tt>”
--   instead.
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAccelGroupAccelChanged :: (IsAccelGroup a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AccelGroupAccelChangedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>is-locked</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> accelGroup #isLocked
--   </pre>
getAccelGroupIsLocked :: (MonadIO m, IsAccelGroup o) => o -> m Bool

-- | Get the value of the “<tt>modifier-mask</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> accelGroup #modifierMask
--   </pre>
getAccelGroupModifierMask :: (MonadIO m, IsAccelGroup o) => o -> m [ModifierType]

-- | Creates a new <a>AccelGroup</a>.
accelGroupNew :: (HasCallStack, MonadIO m) => m AccelGroup

-- | Finds the first accelerator in <i><tt>accelGroup</tt></i> that matches
--   <i><tt>accelKey</tt></i> and <i><tt>accelMods</tt></i>, and activates
--   it.
accelGroupActivate :: (HasCallStack, MonadIO m, IsAccelGroup a, IsObject b) => a -> Word32 -> b -> Word32 -> [ModifierType] -> m Bool

-- | Removes an accelerator previously installed through
--   <a>accelGroupConnect</a>.
--   
--   Since 2.20 <i><tt>closure</tt></i> can be <a>Nothing</a>.
accelGroupDisconnect :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> Maybe (GClosure b) -> m Bool

-- | Removes an accelerator previously installed through
--   <a>accelGroupConnect</a>.
accelGroupDisconnectKey :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> Word32 -> [ModifierType] -> m Bool

-- | Finds the first entry in an accelerator group for which
--   <i><tt>findFunc</tt></i> returns <a>True</a> and returns its
--   <a>AccelKey</a>.
accelGroupFind :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> AccelGroupFindFunc -> m AccelKey

-- | Locks are added and removed using <a>accelGroupLock</a> and
--   <a>accelGroupUnlock</a>.
--   
--   <i>Since: 2.14</i>
accelGroupGetIsLocked :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> m Bool

-- | Gets a <a>ModifierType</a> representing the mask for this
--   <i><tt>accelGroup</tt></i>. For example,
--   <tt><i>GDK_CONTROL_MASK</i></tt>, <tt><i>GDK_SHIFT_MASK</i></tt>, etc.
--   
--   <i>Since: 2.14</i>
accelGroupGetModifierMask :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> m [ModifierType]

-- | Locks the given accelerator group.
--   
--   Locking an acelerator group prevents the accelerators contained within
--   it to be changed during runtime. Refer to <a>accelMapChangeEntry</a>
--   about runtime accelerator changes.
--   
--   If called more than once, <i><tt>accelGroup</tt></i> remains locked
--   until <a>accelGroupUnlock</a> has been called an equivalent number of
--   times.
accelGroupLock :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> m ()

-- | Queries an accelerator group for all entries matching
--   <i><tt>accelKey</tt></i> and <i><tt>accelMods</tt></i>.
accelGroupQuery :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> Word32 -> [ModifierType] -> m (Maybe [AccelGroupEntry])

-- | Undoes the last call to <a>accelGroupLock</a> on this
--   <i><tt>accelGroup</tt></i>.
accelGroupUnlock :: (HasCallStack, MonadIO m, IsAccelGroup a) => a -> m ()

-- | Creates a new <a>TreeModel</a>, with <i><tt>childModel</tt></i> as the
--   child_model and <i><tt>root</tt></i> as the virtual root.
--   
--   <i>Since: 2.4</i>
treeModelFilterNew :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe TreePath -> m TreeModel

-- | Returns the type of the column.
treeModelGetColumnType :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Int32 -> m GType

-- | Initializes <i><tt>iter</tt></i> with the first iterator in the tree
--   (the one at the path "0") and returns <a>True</a>. Returns
--   <a>False</a> if the tree is empty.
treeModelGetIterFirst :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m (Bool, TreeIter)

-- | Sets <i><tt>iter</tt></i> to a valid iterator pointing to
--   <i><tt>pathString</tt></i>, if it exists. Otherwise,
--   <i><tt>iter</tt></i> is left invalid and <a>False</a> is returned.
treeModelGetIterFromString :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Text -> m (Bool, TreeIter)

-- | Returns the number of columns supported by <i><tt>treeModel</tt></i>.
treeModelGetNColumns :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m Int32

-- | Returns a newly-created <a>TreePath</a>-struct referenced by
--   <i><tt>iter</tt></i>.
--   
--   This path should be freed with <a>treePathFree</a>.
treeModelGetPath :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m TreePath

-- | Generates a string representation of the iter.
--   
--   This string is a “:” separated list of numbers. For example,
--   “4:10:0:3” would be an acceptable return value for this string.
--   
--   <i>Since: 2.2</i>
treeModelGetStringFromIter :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m Text

-- | Sets <i><tt>iter</tt></i> to point to the first child of
--   <i><tt>parent</tt></i>.
--   
--   If <i><tt>parent</tt></i> has no children, <a>False</a> is returned
--   and <i><tt>iter</tt></i> is set to be invalid. <i><tt>parent</tt></i>
--   will remain a valid node after this function has been called.
--   
--   If <i><tt>parent</tt></i> is <a>Nothing</a> returns the first node,
--   equivalent to <tt>gtk_tree_model_get_iter_first (tree_model,
--   iter);</tt>
treeModelIterChildren :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe TreeIter -> m (Bool, TreeIter)

-- | Returns <a>True</a> if <i><tt>iter</tt></i> has children, <a>False</a>
--   otherwise.
treeModelIterHasChild :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m Bool

-- | Returns the number of children that <i><tt>iter</tt></i> has.
--   
--   As a special case, if <i><tt>iter</tt></i> is <a>Nothing</a>, then the
--   number of toplevel nodes is returned.
treeModelIterNChildren :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe TreeIter -> m Int32

-- | Sets <i><tt>iter</tt></i> to point to the node following it at the
--   current level.
--   
--   If there is no next <i><tt>iter</tt></i>, <a>False</a> is returned and
--   <i><tt>iter</tt></i> is set to be invalid.
treeModelIterNext :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m Bool

-- | Sets <i><tt>iter</tt></i> to be the child of <i><tt>parent</tt></i>,
--   using the given index.
--   
--   The first index is 0. If <i><tt>n</tt></i> is too big, or
--   <i><tt>parent</tt></i> has no children, <i><tt>iter</tt></i> is set to
--   an invalid iterator and <a>False</a> is returned.
--   <i><tt>parent</tt></i> will remain a valid node after this function
--   has been called. As a special case, if <i><tt>parent</tt></i> is
--   <a>Nothing</a>, then the <i><tt>n</tt></i>-th root node is set.
treeModelIterNthChild :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe TreeIter -> Int32 -> m (Bool, TreeIter)

-- | Sets <i><tt>iter</tt></i> to be the parent of <i><tt>child</tt></i>.
--   
--   If <i><tt>child</tt></i> is at the toplevel, and doesn’t have a
--   parent, then <i><tt>iter</tt></i> is set to an invalid iterator and
--   <a>False</a> is returned. <i><tt>child</tt></i> will remain a valid
--   node after this function has been called.
--   
--   <i><tt>iter</tt></i> will be initialized before the lookup is
--   performed, so <i><tt>child</tt></i> and <i><tt>iter</tt></i> cannot
--   point to the same memory location.
treeModelIterParent :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m (Bool, TreeIter)

-- | Sets <i><tt>iter</tt></i> to point to the previous node at the current
--   level.
--   
--   If there is no previous <i><tt>iter</tt></i>, <a>False</a> is returned
--   and <i><tt>iter</tt></i> is set to be invalid.
--   
--   <i>Since: 3.0</i>
treeModelIterPrevious :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m Bool

-- | Emits the <a>TreeModel::rowChanged</a> signal on
--   <i><tt>treeModel</tt></i>.
treeModelRowChanged :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> TreeIter -> m ()

-- | Emits the <a>TreeModel::rowDeleted</a> signal on
--   <i><tt>treeModel</tt></i>.
--   
--   This should be called by models after a row has been removed. The
--   location pointed to by <i><tt>path</tt></i> should be the location
--   that the row previously was at. It may not be a valid location
--   anymore.
--   
--   Nodes that are deleted are not unreffed, this means that any
--   outstanding references on the deleted node should not be released.
treeModelRowDeleted :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> m ()

-- | Emits the <a>TreeModel::rowHasChildToggled</a> signal on
--   <i><tt>treeModel</tt></i>. This should be called by models after the
--   child state of a node changes.
treeModelRowHasChildToggled :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> TreeIter -> m ()

-- | Emits the <a>TreeModel::rowInserted</a> signal on
--   <i><tt>treeModel</tt></i>.
treeModelRowInserted :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> TreeIter -> m ()

-- | Emits the <a>TreeModel</a>::<tt><i>rows-reordered</i></tt> signal on
--   <i><tt>treeModel</tt></i>.
--   
--   This should be called by models when their rows have been reordered.
--   
--   <i>Since: 3.10</i>
treeModelRowsReordered :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> Maybe TreeIter -> [Int32] -> m ()

-- | Lets the tree unref the node.
--   
--   This is an optional method for models to implement. To be more
--   specific, models may ignore this call as it exists primarily for
--   performance reasons. For more information on what this means, see
--   <a>treeModelRefNode</a>.
--   
--   Please note that nodes that are deleted are not unreffed.
treeModelUnrefNode :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m ()

-- | Connect a signal handler for the <a>rowChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeModel #rowChanged callback
--   </pre>
onTreeModelRowChanged :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeModel #rowChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeModelRowChanged :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowDeleted</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeModel #rowDeleted callback
--   </pre>
onTreeModelRowDeleted :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowDeletedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowDeleted</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeModel #rowDeleted callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeModelRowDeleted :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowDeletedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowHasChildToggled</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeModel #rowHasChildToggled callback
--   </pre>
onTreeModelRowHasChildToggled :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowHasChildToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowHasChildToggled</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeModel #rowHasChildToggled callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeModelRowHasChildToggled :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowHasChildToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowInserted</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeModel #rowInserted callback
--   </pre>
onTreeModelRowInserted :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowInsertedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowInserted</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeModel #rowInserted callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeModelRowInserted :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowInsertedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>clicked</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeViewColumn #clicked callback
--   </pre>
onTreeViewColumnClicked :: (IsTreeViewColumn a, MonadIO m) => a -> ((?self :: a) => TreeViewColumnClickedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>clicked</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeViewColumn #clicked callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewColumnClicked :: (IsTreeViewColumn a, MonadIO m) => a -> ((?self :: a) => TreeViewColumnClickedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>alignment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #alignment
--   </pre>
getTreeViewColumnAlignment :: (MonadIO m, IsTreeViewColumn o) => o -> m Float

-- | Set the value of the “<tt>alignment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #alignment <a>:=</a> value ]
--   </pre>
setTreeViewColumnAlignment :: (MonadIO m, IsTreeViewColumn o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>alignment</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeViewColumnAlignment :: (IsTreeViewColumn o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>cell-area</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #cellArea
--   </pre>
getTreeViewColumnCellArea :: (MonadIO m, IsTreeViewColumn o) => o -> m (Maybe CellArea)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-area</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeViewColumnCellArea :: (IsTreeViewColumn o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>clickable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #clickable
--   </pre>
getTreeViewColumnClickable :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “<tt>clickable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #clickable <a>:=</a> value ]
--   </pre>
setTreeViewColumnClickable :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>clickable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeViewColumnClickable :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>expand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #expand
--   </pre>
getTreeViewColumnExpand :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “<tt>expand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #expand <a>:=</a> value ]
--   </pre>
setTreeViewColumnExpand :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>expand</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeViewColumnExpand :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>fixed-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #fixedWidth
--   </pre>
getTreeViewColumnFixedWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Set the value of the “<tt>fixed-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #fixedWidth <a>:=</a> value ]
--   </pre>
setTreeViewColumnFixedWidth :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fixed-width</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeViewColumnFixedWidth :: (IsTreeViewColumn o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #maxWidth
--   </pre>
getTreeViewColumnMaxWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Set the value of the “<tt>max-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #maxWidth <a>:=</a> value ]
--   </pre>
setTreeViewColumnMaxWidth :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-width</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeViewColumnMaxWidth :: (IsTreeViewColumn o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>min-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #minWidth
--   </pre>
getTreeViewColumnMinWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Set the value of the “<tt>min-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #minWidth <a>:=</a> value ]
--   </pre>
setTreeViewColumnMinWidth :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>min-width</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeViewColumnMinWidth :: (IsTreeViewColumn o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>reorderable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #reorderable
--   </pre>
getTreeViewColumnReorderable :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “<tt>reorderable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #reorderable <a>:=</a> value ]
--   </pre>
setTreeViewColumnReorderable :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>reorderable</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeViewColumnReorderable :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>resizable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #resizable
--   </pre>
getTreeViewColumnResizable :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “<tt>resizable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #resizable <a>:=</a> value ]
--   </pre>
setTreeViewColumnResizable :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>resizable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeViewColumnResizable :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>sizing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #sizing
--   </pre>
getTreeViewColumnSizing :: (MonadIO m, IsTreeViewColumn o) => o -> m TreeViewColumnSizing

-- | Set the value of the “<tt>sizing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #sizing <a>:=</a> value ]
--   </pre>
setTreeViewColumnSizing :: (MonadIO m, IsTreeViewColumn o) => o -> TreeViewColumnSizing -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sizing</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeViewColumnSizing :: (IsTreeViewColumn o, MonadIO m) => TreeViewColumnSizing -> m (GValueConstruct o)

-- | Get the value of the “<tt>sort-column-id</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #sortColumnId
--   </pre>
getTreeViewColumnSortColumnId :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Set the value of the “<tt>sort-column-id</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #sortColumnId <a>:=</a> value ]
--   </pre>
setTreeViewColumnSortColumnId :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sort-column-id</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewColumnSortColumnId :: (IsTreeViewColumn o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>sort-indicator</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #sortIndicator
--   </pre>
getTreeViewColumnSortIndicator :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “<tt>sort-indicator</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #sortIndicator <a>:=</a> value ]
--   </pre>
setTreeViewColumnSortIndicator :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sort-indicator</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewColumnSortIndicator :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>sort-order</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #sortOrder
--   </pre>
getTreeViewColumnSortOrder :: (MonadIO m, IsTreeViewColumn o) => o -> m SortType

-- | Set the value of the “<tt>sort-order</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #sortOrder <a>:=</a> value ]
--   </pre>
setTreeViewColumnSortOrder :: (MonadIO m, IsTreeViewColumn o) => o -> SortType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sort-order</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeViewColumnSortOrder :: (IsTreeViewColumn o, MonadIO m) => SortType -> m (GValueConstruct o)

-- | Get the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #spacing
--   </pre>
getTreeViewColumnSpacing :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Set the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #spacing <a>:=</a> value ]
--   </pre>
setTreeViewColumnSpacing :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>spacing</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeViewColumnSpacing :: (IsTreeViewColumn o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #title
--   </pre>
getTreeViewColumnTitle :: (MonadIO m, IsTreeViewColumn o) => o -> m Text

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #title <a>:=</a> value ]
--   </pre>
setTreeViewColumnTitle :: (MonadIO m, IsTreeViewColumn o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeViewColumnTitle :: (IsTreeViewColumn o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #visible
--   </pre>
getTreeViewColumnVisible :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #visible <a>:=</a> value ]
--   </pre>
setTreeViewColumnVisible :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeViewColumnVisible :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #widget
--   </pre>
getTreeViewColumnWidget :: (MonadIO m, IsTreeViewColumn o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #widget <a>:=</a> value ]
--   </pre>
setTreeViewColumnWidget :: (MonadIO m, IsTreeViewColumn o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>widget</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeViewColumnWidget :: (IsTreeViewColumn o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>widget</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #widget
--   </pre>
clearTreeViewColumnWidget :: (MonadIO m, IsTreeViewColumn o) => o -> m ()

-- | Get the value of the “<tt>width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #width
--   </pre>
getTreeViewColumnWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Get the value of the “<tt>x-offset</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #xOffset
--   </pre>
getTreeViewColumnXOffset :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Creates a new <a>TreeViewColumn</a>.
treeViewColumnNew :: (HasCallStack, MonadIO m) => m TreeViewColumn

-- | Creates a new <a>TreeViewColumn</a> using <i><tt>area</tt></i> to
--   render its cells.
--   
--   <i>Since: 3.0</i>
treeViewColumnNewWithArea :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m TreeViewColumn

-- | Adds an attribute mapping to the list in <i><tt>treeColumn</tt></i>.
--   The <i><tt>column</tt></i> is the column of the model to get a value
--   from, and the <i><tt>attribute</tt></i> is the parameter on
--   <i><tt>cellRenderer</tt></i> to be set from the value. So for example
--   if column 2 of the model contains strings, you could have the “text”
--   attribute of a <a>CellRendererText</a> get its values from column 2.
treeViewColumnAddAttribute :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> Text -> Int32 -> m ()

-- | Obtains the horizontal position and size of a cell in a column. If the
--   cell is not found in the column, <i><tt>startPos</tt></i> and
--   <i><tt>width</tt></i> are not changed and <a>False</a> is returned.
treeViewColumnCellGetPosition :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> m (Bool, Int32, Int32)

-- | Obtains the width and height needed to render the column. This is used
--   primarily by the <a>TreeView</a>.
treeViewColumnCellGetSize :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Maybe Rectangle -> m (Int32, Int32, Int32, Int32)

-- | Returns <a>True</a> if any of the cells packed into the
--   <i><tt>treeColumn</tt></i> are visible. For this to be meaningful, you
--   must first initialize the cells with
--   <a>treeViewColumnCellSetCellData</a>
treeViewColumnCellIsVisible :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Sets the cell renderer based on the <i><tt>treeModel</tt></i> and
--   <i><tt>iter</tt></i>. That is, for every attribute mapping in
--   <i><tt>treeColumn</tt></i>, it will get a value from the set column on
--   the <i><tt>iter</tt></i>, and use that value to set the attribute on
--   the cell renderer. This is used primarily by the <a>TreeView</a>.
treeViewColumnCellSetCellData :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsTreeModel b) => a -> b -> TreeIter -> Bool -> Bool -> m ()

-- | Unsets all the mappings on all renderers on the
--   <i><tt>treeColumn</tt></i>.
treeViewColumnClear :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m ()

-- | Clears all existing attributes previously set with
--   <tt><i>gtk_tree_view_column_set_attributes()</i></tt>.
treeViewColumnClearAttributes :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> m ()

-- | Emits the “clicked” signal on the column. This function will only work
--   if <i><tt>treeColumn</tt></i> is clickable.
treeViewColumnClicked :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m ()

-- | Sets the current keyboard focus to be at <i><tt>cell</tt></i>, if the
--   column contains 2 or more editable and activatable cells.
--   
--   <i>Since: 2.2</i>
treeViewColumnFocusCell :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> m ()

-- | Returns the current x alignment of <i><tt>treeColumn</tt></i>. This
--   value can range between 0.0 and 1.0.
treeViewColumnGetAlignment :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Float

-- | Returns the button used in the treeview column header
--   
--   <i>Since: 3.0</i>
treeViewColumnGetButton :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Widget

-- | Returns <a>True</a> if the user can click on the header for the
--   column.
treeViewColumnGetClickable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Returns <a>True</a> if the column expands to fill available space.
--   
--   <i>Since: 2.4</i>
treeViewColumnGetExpand :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Gets the fixed width of the column. This may not be the actual
--   displayed width of the column; for that, use
--   <a>treeViewColumnGetWidth</a>.
treeViewColumnGetFixedWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Returns the maximum width in pixels of the <i><tt>treeColumn</tt></i>,
--   or -1 if no maximum width is set.
treeViewColumnGetMaxWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Returns the minimum width in pixels of the <i><tt>treeColumn</tt></i>,
--   or -1 if no minimum width is set.
treeViewColumnGetMinWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Returns <a>True</a> if the <i><tt>treeColumn</tt></i> can be reordered
--   by the user.
treeViewColumnGetReorderable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Returns <a>True</a> if the <i><tt>treeColumn</tt></i> can be resized
--   by the end user.
treeViewColumnGetResizable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Returns the current type of <i><tt>treeColumn</tt></i>.
treeViewColumnGetSizing :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m TreeViewColumnSizing

-- | Gets the logical <i><tt>sortColumnId</tt></i> that the model sorts on
--   when this column is selected for sorting. See
--   <a>treeViewColumnSetSortColumnId</a>.
treeViewColumnGetSortColumnId :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Gets the value set by <a>treeViewColumnSetSortIndicator</a>.
treeViewColumnGetSortIndicator :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Gets the value set by <a>treeViewColumnSetSortOrder</a>.
treeViewColumnGetSortOrder :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m SortType

-- | Returns the spacing of <i><tt>treeColumn</tt></i>.
treeViewColumnGetSpacing :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Returns the title of the widget.
treeViewColumnGetTitle :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Text

-- | Returns the <a>TreeView</a> wherein <i><tt>treeColumn</tt></i> has
--   been inserted. If <i><tt>column</tt></i> is currently not inserted in
--   any tree view, <a>Nothing</a> is returned.
--   
--   <i>Since: 2.12</i>
treeViewColumnGetTreeView :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m (Maybe Widget)

-- | Returns <a>True</a> if <i><tt>treeColumn</tt></i> is visible.
treeViewColumnGetVisible :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Returns the <a>Widget</a> in the button on the column header. If a
--   custom widget has not been set then <a>Nothing</a> is returned.
treeViewColumnGetWidget :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m (Maybe Widget)

-- | Returns the current size of <i><tt>treeColumn</tt></i> in pixels.
treeViewColumnGetWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Returns the current X offset of <i><tt>treeColumn</tt></i> in pixels.
--   
--   <i>Since: 3.2</i>
treeViewColumnGetXOffset :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Adds the <i><tt>cell</tt></i> to end of the column. If
--   <i><tt>expand</tt></i> is <a>False</a>, then the <i><tt>cell</tt></i>
--   is allocated no more space than it needs. Any unused space is divided
--   evenly between cells for which <i><tt>expand</tt></i> is <a>True</a>.
treeViewColumnPackEnd :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> Bool -> m ()

-- | Flags the column, and the cell renderers added to this column, to have
--   their sizes renegotiated.
--   
--   <i>Since: 2.8</i>
treeViewColumnQueueResize :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m ()

-- | Sets the alignment of the title or custom widget inside the column
--   header. The alignment determines its location inside the button -- 0.0
--   for left, 0.5 for center, 1.0 for right.
treeViewColumnSetAlignment :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Float -> m ()

-- | Sets the header to be active if <i><tt>clickable</tt></i> is
--   <a>True</a>. When the header is active, then it can take keyboard
--   focus, and can be clicked.
treeViewColumnSetClickable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Bool -> m ()

-- | Sets the column to take available extra space. This space is shared
--   equally amongst all columns that have the expand set to <a>True</a>.
--   If no column has this option set, then the last column gets all extra
--   space. By default, every column is created with this <a>False</a>.
--   
--   Along with “fixed-width”, the “expand” property changes when the
--   column is resized by the user.
--   
--   <i>Since: 2.4</i>
treeViewColumnSetExpand :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Bool -> m ()

-- | If <i><tt>fixedWidth</tt></i> is not -1, sets the fixed width of
--   <i><tt>treeColumn</tt></i>; otherwise unsets it. The effective value
--   of <i><tt>fixedWidth</tt></i> is clamped between the minimum and
--   maximum width of the column; however, the value stored in the
--   “fixed-width” property is not clamped. If the column sizing is
--   <tt><i>GTK_TREE_VIEW_COLUMN_GROW_ONLY</i></tt> or
--   <tt><i>GTK_TREE_VIEW_COLUMN_AUTOSIZE</i></tt>, setting a fixed width
--   overrides the automatically calculated width. Note that
--   <i><tt>fixedWidth</tt></i> is only a hint to GTK+; the width actually
--   allocated to the column may be greater or less than requested.
--   
--   Along with “expand”, the “fixed-width” property changes when the
--   column is resized by the user.
treeViewColumnSetFixedWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Int32 -> m ()

-- | Sets the maximum width of the <i><tt>treeColumn</tt></i>. If
--   <i><tt>maxWidth</tt></i> is -1, then the maximum width is unset. Note,
--   the column can actually be wider than max width if it’s the last
--   column in a view. In this case, the column expands to fill any extra
--   space.
treeViewColumnSetMaxWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Int32 -> m ()

-- | Sets the minimum width of the <i><tt>treeColumn</tt></i>. If
--   <i><tt>minWidth</tt></i> is -1, then the minimum width is unset.
treeViewColumnSetMinWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Int32 -> m ()

-- | If <i><tt>reorderable</tt></i> is <a>True</a>, then the column can be
--   reordered by the end user dragging the header.
treeViewColumnSetReorderable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Bool -> m ()

-- | If <i><tt>resizable</tt></i> is <a>True</a>, then the user can
--   explicitly resize the column by grabbing the outer edge of the column
--   button. If resizable is <a>True</a> and sizing mode of the column is
--   <tt><i>GTK_TREE_VIEW_COLUMN_AUTOSIZE</i></tt>, then the sizing mode is
--   changed to <tt><i>GTK_TREE_VIEW_COLUMN_GROW_ONLY</i></tt>.
treeViewColumnSetResizable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Bool -> m ()

-- | Sets the growth behavior of <i><tt>treeColumn</tt></i> to
--   <i><tt>type</tt></i>.
treeViewColumnSetSizing :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> TreeViewColumnSizing -> m ()

-- | Sets the logical <i><tt>sortColumnId</tt></i> that this column sorts
--   on when this column is selected for sorting. Doing so makes the column
--   header clickable.
treeViewColumnSetSortColumnId :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Int32 -> m ()

-- | Call this function with a <i><tt>setting</tt></i> of <a>True</a> to
--   display an arrow in the header button indicating the column is sorted.
--   Call <a>treeViewColumnSetSortOrder</a> to change the direction of the
--   arrow.
treeViewColumnSetSortIndicator :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Bool -> m ()

-- | Changes the appearance of the sort indicator.
--   
--   This does not actually sort the model. Use
--   <a>treeViewColumnSetSortColumnId</a> if you want automatic sorting
--   support. This function is primarily for custom sorting behavior, and
--   should be used in conjunction with <a>treeSortableSetSortColumnId</a>
--   to do that. For custom models, the mechanism will vary.
--   
--   The sort indicator changes direction to indicate normal sort or
--   reverse sort. Note that you must have the sort indicator enabled to
--   see anything when calling this function; see
--   <a>treeViewColumnSetSortIndicator</a>.
treeViewColumnSetSortOrder :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> SortType -> m ()

-- | Sets the spacing field of <i><tt>treeColumn</tt></i>, which is the
--   number of pixels to place between cell renderers packed into it.
treeViewColumnSetSpacing :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Int32 -> m ()

-- | Sets the title of the <i><tt>treeColumn</tt></i>. If a custom widget
--   has been set, then this value is ignored.
treeViewColumnSetTitle :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Text -> m ()

-- | Sets the visibility of <i><tt>treeColumn</tt></i>.
treeViewColumnSetVisible :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Bool -> m ()

-- | Sets the widget in the header to be <i><tt>widget</tt></i>. If widget
--   is <a>Nothing</a>, then the header button is set with a <a>Label</a>
--   set to the title of <i><tt>treeColumn</tt></i>.
treeViewColumnSetWidget :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsWidget b) => a -> Maybe b -> m ()

-- | Connect a signal handler for the <a>editingCanceled</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> cellRenderer #editingCanceled callback
--   </pre>
onCellRendererEditingCanceled :: (IsCellRenderer a, MonadIO m) => a -> ((?self :: a) => CellRendererEditingCanceledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>editingCanceled</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> cellRenderer #editingCanceled callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellRendererEditingCanceled :: (IsCellRenderer a, MonadIO m) => a -> ((?self :: a) => CellRendererEditingCanceledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>editingStarted</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> cellRenderer #editingStarted callback
--   </pre>
onCellRendererEditingStarted :: (IsCellRenderer a, MonadIO m) => a -> ((?self :: a) => CellRendererEditingStartedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>editingStarted</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> cellRenderer #editingStarted callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellRendererEditingStarted :: (IsCellRenderer a, MonadIO m) => a -> ((?self :: a) => CellRendererEditingStartedCallback) -> m SignalHandlerId

-- | Set the value of the “<tt>cell-background</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #cellBackground <a>:=</a> value ]
--   </pre>
setCellRendererCellBackground :: (MonadIO m, IsCellRenderer o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-background</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererCellBackground :: (IsCellRenderer o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>cell-background</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #cellBackground
--   </pre>
clearCellRendererCellBackground :: (MonadIO m, IsCellRenderer o) => o -> m ()

-- | Get the value of the “<tt>cell-background-gdk</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #cellBackgroundGdk
--   </pre>
getCellRendererCellBackgroundGdk :: (MonadIO m, IsCellRenderer o) => o -> m (Maybe Color)

-- | Set the value of the “<tt>cell-background-gdk</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #cellBackgroundGdk <a>:=</a> value ]
--   </pre>
setCellRendererCellBackgroundGdk :: (MonadIO m, IsCellRenderer o) => o -> Color -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-background-gdk</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCellRendererCellBackgroundGdk :: (IsCellRenderer o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Set the value of the “<tt>cell-background-gdk</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #cellBackgroundGdk
--   </pre>
clearCellRendererCellBackgroundGdk :: (MonadIO m, IsCellRenderer o) => o -> m ()

-- | Get the value of the “<tt>cell-background-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #cellBackgroundRgba
--   </pre>
getCellRendererCellBackgroundRgba :: (MonadIO m, IsCellRenderer o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>cell-background-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #cellBackgroundRgba <a>:=</a> value ]
--   </pre>
setCellRendererCellBackgroundRgba :: (MonadIO m, IsCellRenderer o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-background-rgba</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCellRendererCellBackgroundRgba :: (IsCellRenderer o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “<tt>cell-background-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #cellBackgroundRgba
--   </pre>
clearCellRendererCellBackgroundRgba :: (MonadIO m, IsCellRenderer o) => o -> m ()

-- | Get the value of the “<tt>cell-background-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #cellBackgroundSet
--   </pre>
getCellRendererCellBackgroundSet :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Set the value of the “<tt>cell-background-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #cellBackgroundSet <a>:=</a> value ]
--   </pre>
setCellRendererCellBackgroundSet :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-background-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCellRendererCellBackgroundSet :: (IsCellRenderer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>editing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #editing
--   </pre>
getCellRendererEditing :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Get the value of the “<tt>height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #height
--   </pre>
getCellRendererHeight :: (MonadIO m, IsCellRenderer o) => o -> m Int32

-- | Set the value of the “<tt>height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #height <a>:=</a> value ]
--   </pre>
setCellRendererHeight :: (MonadIO m, IsCellRenderer o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>height</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererHeight :: (IsCellRenderer o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>is-expanded</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #isExpanded
--   </pre>
getCellRendererIsExpanded :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Set the value of the “<tt>is-expanded</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #isExpanded <a>:=</a> value ]
--   </pre>
setCellRendererIsExpanded :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>is-expanded</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererIsExpanded :: (IsCellRenderer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>is-expander</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #isExpander
--   </pre>
getCellRendererIsExpander :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Set the value of the “<tt>is-expander</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #isExpander <a>:=</a> value ]
--   </pre>
setCellRendererIsExpander :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>is-expander</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererIsExpander :: (IsCellRenderer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>mode</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #mode
--   </pre>
getCellRendererMode :: (MonadIO m, IsCellRenderer o) => o -> m CellRendererMode

-- | Set the value of the “<tt>mode</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #mode <a>:=</a> value ]
--   </pre>
setCellRendererMode :: (MonadIO m, IsCellRenderer o) => o -> CellRendererMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>mode</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererMode :: (IsCellRenderer o, MonadIO m) => CellRendererMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #sensitive
--   </pre>
getCellRendererSensitive :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Set the value of the “<tt>sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #sensitive <a>:=</a> value ]
--   </pre>
setCellRendererSensitive :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sensitive</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererSensitive :: (IsCellRenderer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #visible
--   </pre>
getCellRendererVisible :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Set the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #visible <a>:=</a> value ]
--   </pre>
setCellRendererVisible :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererVisible :: (IsCellRenderer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #width
--   </pre>
getCellRendererWidth :: (MonadIO m, IsCellRenderer o) => o -> m Int32

-- | Set the value of the “<tt>width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #width <a>:=</a> value ]
--   </pre>
setCellRendererWidth :: (MonadIO m, IsCellRenderer o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>width</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererWidth :: (IsCellRenderer o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #xalign
--   </pre>
getCellRendererXalign :: (MonadIO m, IsCellRenderer o) => o -> m Float

-- | Set the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #xalign <a>:=</a> value ]
--   </pre>
setCellRendererXalign :: (MonadIO m, IsCellRenderer o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>xalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererXalign :: (IsCellRenderer o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>xpad</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #xpad
--   </pre>
getCellRendererXpad :: (MonadIO m, IsCellRenderer o) => o -> m Word32

-- | Set the value of the “<tt>xpad</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #xpad <a>:=</a> value ]
--   </pre>
setCellRendererXpad :: (MonadIO m, IsCellRenderer o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>xpad</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererXpad :: (IsCellRenderer o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #yalign
--   </pre>
getCellRendererYalign :: (MonadIO m, IsCellRenderer o) => o -> m Float

-- | Set the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #yalign <a>:=</a> value ]
--   </pre>
setCellRendererYalign :: (MonadIO m, IsCellRenderer o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>yalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererYalign :: (IsCellRenderer o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>ypad</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #ypad
--   </pre>
getCellRendererYpad :: (MonadIO m, IsCellRenderer o) => o -> m Word32

-- | Set the value of the “<tt>ypad</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #ypad <a>:=</a> value ]
--   </pre>
setCellRendererYpad :: (MonadIO m, IsCellRenderer o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ypad</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererYpad :: (IsCellRenderer o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Passes an activate event to the cell renderer for possible processing.
--   Some cell renderers may use events; for example,
--   <a>CellRendererToggle</a> toggles when it gets a mouse click.
cellRendererActivate :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> Event -> b -> Text -> Rectangle -> Rectangle -> [CellRendererState] -> m Bool

-- | Gets the aligned area used by <i><tt>cell</tt></i> inside
--   <i><tt>cellArea</tt></i>. Used for finding the appropriate edit and
--   focus rectangle.
--   
--   <i>Since: 3.0</i>
cellRendererGetAlignedArea :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> [CellRendererState] -> Rectangle -> m Rectangle

-- | Fills in <i><tt>xalign</tt></i> and <i><tt>yalign</tt></i> with the
--   appropriate values of <i><tt>cell</tt></i>.
--   
--   <i>Since: 2.18</i>
cellRendererGetAlignment :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m (Float, Float)

-- | Fills in <i><tt>width</tt></i> and <i><tt>height</tt></i> with the
--   appropriate size of <i><tt>cell</tt></i>.
cellRendererGetFixedSize :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m (Int32, Int32)

-- | Fills in <i><tt>xpad</tt></i> and <i><tt>ypad</tt></i> with the
--   appropriate values of <i><tt>cell</tt></i>.
--   
--   <i>Since: 2.18</i>
cellRendererGetPadding :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m (Int32, Int32)

-- | Retreives a renderer’s natural size when rendered to
--   <i><tt>widget</tt></i>.
--   
--   <i>Since: 3.0</i>
cellRendererGetPreferredHeight :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> m (Int32, Int32)

-- | Retreives a cell renderers’s minimum and natural height if it were
--   rendered to <i><tt>widget</tt></i> with the specified
--   <i><tt>width</tt></i>.
--   
--   <i>Since: 3.0</i>
cellRendererGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> Int32 -> m (Int32, Int32)

-- | Retrieves the minimum and natural size of a cell taking into account
--   the widget’s preference for height-for-width management.
--   
--   <i>Since: 3.0</i>
cellRendererGetPreferredSize :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> m (Requisition, Requisition)

-- | Retreives a renderer’s natural size when rendered to
--   <i><tt>widget</tt></i>.
--   
--   <i>Since: 3.0</i>
cellRendererGetPreferredWidth :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> m (Int32, Int32)

-- | Retreives a cell renderers’s minimum and natural width if it were
--   rendered to <i><tt>widget</tt></i> with the specified
--   <i><tt>height</tt></i>.
--   
--   <i>Since: 3.0</i>
cellRendererGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> Int32 -> m (Int32, Int32)

-- | Gets whether the cell renderer prefers a height-for-width layout or a
--   width-for-height layout.
--   
--   <i>Since: 3.0</i>
cellRendererGetRequestMode :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m SizeRequestMode

-- | Returns the cell renderer’s sensitivity.
--   
--   <i>Since: 2.18</i>
cellRendererGetSensitive :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m Bool

-- | Obtains the width and height needed to render the cell. Used by view
--   widgets to determine the appropriate size for the cell_area passed to
--   <a>cellRendererRender</a>. If <i><tt>cellArea</tt></i> is not
--   <a>Nothing</a>, fills in the x and y offsets (if set) of the cell
--   relative to this location.
--   
--   Please note that the values set in <i><tt>width</tt></i> and
--   <i><tt>height</tt></i>, as well as those in <i><tt>xOffset</tt></i>
--   and <i><tt>yOffset</tt></i> are inclusive of the xpad and ypad
--   properties.
cellRendererGetSize :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> Maybe Rectangle -> m (Int32, Int32, Int32, Int32)

-- | Translates the cell renderer state to <a>StateFlags</a>, based on the
--   cell renderer and widget sensitivity, and the given
--   <a>CellRendererState</a>.
--   
--   <i>Since: 3.0</i>
cellRendererGetState :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => Maybe a -> Maybe b -> [CellRendererState] -> m [StateFlags]

-- | Returns the cell renderer’s visibility.
--   
--   <i>Since: 2.18</i>
cellRendererGetVisible :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m Bool

-- | Checks whether the cell renderer can do something when activated.
--   
--   <i>Since: 3.0</i>
cellRendererIsActivatable :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m Bool

-- | Sets the renderer’s alignment within its available space.
--   
--   <i>Since: 2.18</i>
cellRendererSetAlignment :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Float -> Float -> m ()

-- | Sets the renderer size to be explicit, independent of the properties
--   set.
cellRendererSetFixedSize :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Int32 -> Int32 -> m ()

-- | Sets the renderer’s padding.
--   
--   <i>Since: 2.18</i>
cellRendererSetPadding :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Int32 -> Int32 -> m ()

-- | Sets the cell renderer’s sensitivity.
--   
--   <i>Since: 2.18</i>
cellRendererSetSensitive :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Bool -> m ()

-- | Sets the cell renderer’s visibility.
--   
--   <i>Since: 2.18</i>
cellRendererSetVisible :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Bool -> m ()

-- | Informs the cell renderer that the editing is stopped. If
--   <i><tt>canceled</tt></i> is <a>True</a>, the cell renderer will emit
--   the <a>CellRenderer::editingCanceled</a> signal.
--   
--   This function should be called by cell renderer implementations in
--   response to the <a>CellEditable::editingDone</a> signal of
--   <a>CellEditable</a>.
--   
--   <i>Since: 2.6</i>
cellRendererStopEditing :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Bool -> m ()

-- | Returns the <a>IconFactory</a> defined to be in use for
--   <i><tt>path</tt></i>, or <a>Nothing</a> if none is defined.
--   
--   <i>Since: 3.0</i>
styleProviderGetIconFactory :: (HasCallStack, MonadIO m, IsStyleProvider a) => a -> WidgetPath -> m (Maybe IconFactory)

-- | Returns the style settings affecting a widget defined by
--   <i><tt>path</tt></i>, or <a>Nothing</a> if <i><tt>provider</tt></i>
--   doesn’t contemplate styling <i><tt>path</tt></i>.
--   
--   <i>Since: 3.0</i>
styleProviderGetStyle :: (HasCallStack, MonadIO m, IsStyleProvider a) => a -> WidgetPath -> m (Maybe StyleProperties)

-- | Looks up a widget style property as defined by
--   <i><tt>provider</tt></i> for the widget represented by
--   <i><tt>path</tt></i>.
--   
--   <i>Since: 3.0</i>
styleProviderGetStyleProperty :: (HasCallStack, MonadIO m, IsStyleProvider a) => a -> WidgetPath -> [StateFlags] -> GParamSpec -> m (Bool, GValue)

-- | Adds a child to <i><tt>buildable</tt></i>. <i><tt>type</tt></i> is an
--   optional string describing how the child should be added.
--   
--   <i>Since: 2.12</i>
buildableAddChild :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b, IsObject c) => a -> b -> c -> Maybe Text -> m ()

-- | Constructs a child of <i><tt>buildable</tt></i> with the name
--   <i><tt>name</tt></i>.
--   
--   <a>Builder</a> calls this function if a “constructor” has been
--   specified in the UI definition.
--   
--   <i>Since: 2.12</i>
buildableConstructChild :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b) => a -> b -> Text -> m Object

-- | This is similar to <a>buildableParserFinished</a> but is called once
--   for each custom tag handled by the <i><tt>buildable</tt></i>.
--   
--   <i>Since: 2.12</i>
buildableCustomFinished :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b, IsObject c) => a -> b -> Maybe c -> Text -> Ptr () -> m ()

-- | This is called at the end of each custom element handled by the
--   buildable.
--   
--   <i>Since: 2.12</i>
buildableCustomTagEnd :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b, IsObject c) => a -> b -> Maybe c -> Text -> Ptr () -> m ()

-- | This is called for each unknown element under <tt>&lt;child&gt;</tt>.
--   
--   <i>Since: 2.12</i>
buildableCustomTagStart :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b, IsObject c) => a -> b -> Maybe c -> Text -> m (Bool, MarkupParser, Ptr ())

-- | Get the internal child called <i><tt>childname</tt></i> of the
--   <i><tt>buildable</tt></i> object.
--   
--   <i>Since: 2.12</i>
buildableGetInternalChild :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b) => a -> b -> Text -> m Object

-- | Gets the name of the <i><tt>buildable</tt></i> object.
--   
--   <a>Builder</a> sets the name based on the [GtkBuilder UI
--   definition][BUILDER-UI] used to construct the
--   <i><tt>buildable</tt></i>.
--   
--   <i>Since: 2.12</i>
buildableGetName :: (HasCallStack, MonadIO m, IsBuildable a) => a -> m Text

-- | Called when the builder finishes the parsing of a [GtkBuilder UI
--   definition][BUILDER-UI]. Note that this will be called once for each
--   time <a>builderAddFromFile</a> or <a>builderAddFromString</a> is
--   called on a builder.
--   
--   <i>Since: 2.12</i>
buildableParserFinished :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b) => a -> b -> m ()

-- | Sets the property name <i><tt>name</tt></i> to <i><tt>value</tt></i>
--   on the <i><tt>buildable</tt></i> object.
--   
--   <i>Since: 2.12</i>
buildableSetBuildableProperty :: (HasCallStack, MonadIO m, IsBuildable a, IsBuilder b) => a -> b -> Text -> GValue -> m ()

-- | Sets the name of the <i><tt>buildable</tt></i> object.
--   
--   <i>Since: 2.12</i>
buildableSetName :: (HasCallStack, MonadIO m, IsBuildable a) => a -> Text -> m ()

-- | Get the value of the “<tt>editing-canceled</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellEditable #editingCanceled
--   </pre>
getCellEditableEditingCanceled :: (MonadIO m, IsCellEditable o) => o -> m Bool

-- | Set the value of the “<tt>editing-canceled</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellEditable [ #editingCanceled <a>:=</a> value ]
--   </pre>
setCellEditableEditingCanceled :: (MonadIO m, IsCellEditable o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>editing-canceled</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellEditableEditingCanceled :: (IsCellEditable o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Emits the <a>CellEditable::editingDone</a> signal.
cellEditableEditingDone :: (HasCallStack, MonadIO m, IsCellEditable a) => a -> m ()

-- | Emits the <a>CellEditable::removeWidget</a> signal.
cellEditableRemoveWidget :: (HasCallStack, MonadIO m, IsCellEditable a) => a -> m ()

-- | Connect a signal handler for the <a>editingDone</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellEditable #editingDone callback
--   </pre>
onCellEditableEditingDone :: (IsCellEditable a, MonadIO m) => a -> ((?self :: a) => CellEditableEditingDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>editingDone</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellEditable #editingDone callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellEditableEditingDone :: (IsCellEditable a, MonadIO m) => a -> ((?self :: a) => CellEditableEditingDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>removeWidget</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellEditable #removeWidget callback
--   </pre>
onCellEditableRemoveWidget :: (IsCellEditable a, MonadIO m) => a -> ((?self :: a) => CellEditableRemoveWidgetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>removeWidget</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellEditable #removeWidget callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellEditableRemoveWidget :: (IsCellEditable a, MonadIO m) => a -> ((?self :: a) => CellEditableRemoveWidgetCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>area</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellAreaContext #area
--   </pre>
getCellAreaContextArea :: (MonadIO m, IsCellAreaContext o) => o -> m CellArea

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>area</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellAreaContextArea :: (IsCellAreaContext o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>minimum-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellAreaContext #minimumHeight
--   </pre>
getCellAreaContextMinimumHeight :: (MonadIO m, IsCellAreaContext o) => o -> m Int32

-- | Get the value of the “<tt>minimum-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellAreaContext #minimumWidth
--   </pre>
getCellAreaContextMinimumWidth :: (MonadIO m, IsCellAreaContext o) => o -> m Int32

-- | Get the value of the “<tt>natural-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellAreaContext #naturalHeight
--   </pre>
getCellAreaContextNaturalHeight :: (MonadIO m, IsCellAreaContext o) => o -> m Int32

-- | Get the value of the “<tt>natural-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellAreaContext #naturalWidth
--   </pre>
getCellAreaContextNaturalWidth :: (MonadIO m, IsCellAreaContext o) => o -> m Int32

-- | Allocates a width and/or a height for all rows which are to be
--   rendered with <i><tt>context</tt></i>.
--   
--   Usually allocation is performed only horizontally or sometimes
--   vertically since a group of rows are usually rendered side by side
--   vertically or horizontally and share either the same width or the same
--   height. Sometimes they are allocated in both horizontal and vertical
--   orientations producing a homogeneous effect of the rows. This is
--   generally the case for <a>TreeView</a> when
--   <a>TreeView:fixedHeightMode</a> is enabled.
--   
--   Since 3.0
cellAreaContextAllocate :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> Int32 -> m ()

-- | Fetches the current allocation size for <i><tt>context</tt></i>.
--   
--   If the context was not allocated in width or height, or if the context
--   was recently reset with <a>cellAreaContextReset</a>, the returned
--   value will be -1.
--   
--   <i>Since: 3.0</i>
cellAreaContextGetAllocation :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m (Int32, Int32)

-- | Fetches the <a>CellArea</a> this <i><tt>context</tt></i> was created
--   by.
--   
--   This is generally unneeded by layouting widgets; however, it is
--   important for the context implementation itself to fetch information
--   about the area it is being used for.
--   
--   For instance at <a>CellAreaContextClass</a>.<tt><i>allocate</i></tt>()
--   time it’s important to know details about any cell spacing that the
--   <a>CellArea</a> is configured with in order to compute a proper
--   allocation.
--   
--   <i>Since: 3.0</i>
cellAreaContextGetArea :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m CellArea

-- | Gets the accumulative preferred height for <i><tt>width</tt></i> for
--   all rows which have been requested for the same said
--   <i><tt>width</tt></i> with this context.
--   
--   After <a>cellAreaContextReset</a> is called and/or before ever
--   requesting the size of a <a>CellArea</a>, the returned values are -1.
--   
--   <i>Since: 3.0</i>
cellAreaContextGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> m (Int32, Int32)

-- | Gets the accumulative preferred width for <i><tt>height</tt></i> for
--   all rows which have been requested for the same said
--   <i><tt>height</tt></i> with this context.
--   
--   After <a>cellAreaContextReset</a> is called and/or before ever
--   requesting the size of a <a>CellArea</a>, the returned values are -1.
--   
--   <i>Since: 3.0</i>
cellAreaContextGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> m (Int32, Int32)

-- | Causes the minimum and/or natural height to grow if the new proposed
--   sizes exceed the current minimum and natural height.
--   
--   This is used by <a>CellAreaContext</a> implementations during the
--   request process over a series of <a>TreeModel</a> rows to
--   progressively push the requested height over a series of
--   <a>cellAreaGetPreferredHeight</a> requests.
--   
--   <i>Since: 3.0</i>
cellAreaContextPushPreferredHeight :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> Int32 -> m ()

-- | Causes the minimum and/or natural width to grow if the new proposed
--   sizes exceed the current minimum and natural width.
--   
--   This is used by <a>CellAreaContext</a> implementations during the
--   request process over a series of <a>TreeModel</a> rows to
--   progressively push the requested width over a series of
--   <a>cellAreaGetPreferredWidth</a> requests.
--   
--   <i>Since: 3.0</i>
cellAreaContextPushPreferredWidth :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> Int32 -> m ()

-- | Resets any previously cached request and allocation data.
--   
--   When underlying <a>TreeModel</a> data changes its important to reset
--   the context if the content size is allowed to shrink. If the content
--   size is only allowed to grow (this is usually an option for views
--   rendering large data stores as a measure of optimization), then only
--   the row that changed or was inserted needs to be (re)requested with
--   <a>cellAreaGetPreferredWidth</a>.
--   
--   When the new overall size of the context requires that the allocated
--   size changes (or whenever this allocation changes at all), the
--   variable row sizes need to be re-requested for every row.
--   
--   For instance, if the rows are displayed all with the same width from
--   top to bottom then a change in the allocated width necessitates a
--   recalculation of all the displayed row heights using
--   <a>cellAreaGetPreferredHeightForWidth</a>.
--   
--   Since 3.0
cellAreaContextReset :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m ()

-- | Connect a signal handler for the <a>addEditable</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellArea #addEditable callback
--   </pre>
onCellAreaAddEditable :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaAddEditableCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>addEditable</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellArea #addEditable callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellAreaAddEditable :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaAddEditableCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>applyAttributes</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> cellArea #applyAttributes callback
--   </pre>
onCellAreaApplyAttributes :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaApplyAttributesCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>applyAttributes</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> cellArea #applyAttributes callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellAreaApplyAttributes :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaApplyAttributesCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>focusChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellArea #focusChanged callback
--   </pre>
onCellAreaFocusChanged :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaFocusChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>focusChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellArea #focusChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellAreaFocusChanged :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaFocusChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>removeEditable</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> cellArea #removeEditable callback
--   </pre>
onCellAreaRemoveEditable :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaRemoveEditableCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>removeEditable</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> cellArea #removeEditable callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellAreaRemoveEditable :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaRemoveEditableCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>edit-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellArea #editWidget
--   </pre>
getCellAreaEditWidget :: (MonadIO m, IsCellArea o) => o -> m CellEditable

-- | Get the value of the “<tt>edited-cell</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellArea #editedCell
--   </pre>
getCellAreaEditedCell :: (MonadIO m, IsCellArea o) => o -> m CellRenderer

-- | Get the value of the “<tt>focus-cell</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellArea #focusCell
--   </pre>
getCellAreaFocusCell :: (MonadIO m, IsCellArea o) => o -> m CellRenderer

-- | Set the value of the “<tt>focus-cell</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellArea [ #focusCell <a>:=</a> value ]
--   </pre>
setCellAreaFocusCell :: (MonadIO m, IsCellArea o, IsCellRenderer a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>focus-cell</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellAreaFocusCell :: (IsCellArea o, MonadIO m, IsCellRenderer a) => a -> m (GValueConstruct o)

-- | Activates <i><tt>area</tt></i>, usually by activating the currently
--   focused cell, however some subclasses which embed widgets in the area
--   can also activate a widget if it currently has the focus.
--   
--   <i>Since: 3.0</i>
cellAreaActivate :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Rectangle -> [CellRendererState] -> Bool -> m Bool

-- | This is used by <a>CellArea</a> subclasses when handling events to
--   activate cells, the base <a>CellArea</a> class activates cells for
--   keyboard events for free in its own
--   GtkCellArea-&gt;<tt><i>activate()</i></tt> implementation.
--   
--   <i>Since: 3.0</i>
cellAreaActivateCell :: (HasCallStack, MonadIO m, IsCellArea a, IsWidget b, IsCellRenderer c) => a -> b -> c -> Event -> Rectangle -> [CellRendererState] -> m Bool

-- | Adds <i><tt>renderer</tt></i> to <i><tt>area</tt></i> with the default
--   child cell properties.
--   
--   <i>Since: 3.0</i>
cellAreaAdd :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m ()

-- | Adds <i><tt>sibling</tt></i> to <i><tt>renderer</tt></i>’s focusable
--   area, focus will be drawn around <i><tt>renderer</tt></i> and all of
--   its siblings if <i><tt>renderer</tt></i> can focus for a given row.
--   
--   Events handled by focus siblings can also activate the given focusable
--   <i><tt>renderer</tt></i>.
--   
--   <i>Since: 3.0</i>
cellAreaAddFocusSibling :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b, IsCellRenderer c) => a -> b -> c -> m ()

-- | Applies any connected attributes to the renderers in
--   <i><tt>area</tt></i> by pulling the values from
--   <i><tt>treeModel</tt></i>.
--   
--   <i>Since: 3.0</i>
cellAreaApplyAttributes :: (HasCallStack, MonadIO m, IsCellArea a, IsTreeModel b) => a -> b -> TreeIter -> Bool -> Bool -> m ()

-- | Connects an <i><tt>attribute</tt></i> to apply values from
--   <i><tt>column</tt></i> for the <a>TreeModel</a> in use.
--   
--   <i>Since: 3.0</i>
cellAreaAttributeConnect :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> Text -> Int32 -> m ()

-- | Disconnects <i><tt>attribute</tt></i> for the <i><tt>renderer</tt></i>
--   in <i><tt>area</tt></i> so that attribute will no longer be updated
--   with values from the model.
--   
--   <i>Since: 3.0</i>
cellAreaAttributeDisconnect :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> Text -> m ()

-- | Returns the model column that an attribute has been mapped to, or -1
--   if the attribute is not mapped.
--   
--   <i>Since: 3.14</i>
cellAreaAttributeGetColumn :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> Text -> m Int32

-- | Gets the value of a cell property for <i><tt>renderer</tt></i> in
--   <i><tt>area</tt></i>.
--   
--   <i>Since: 3.0</i>
cellAreaCellGetProperty :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> Text -> GValue -> m ()

-- | Sets a cell property for <i><tt>renderer</tt></i> in
--   <i><tt>area</tt></i>.
--   
--   <i>Since: 3.0</i>
cellAreaCellSetProperty :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> Text -> GValue -> m ()

-- | This is sometimes needed for cases where rows need to share alignments
--   in one orientation but may be separately grouped in the opposing
--   orientation.
--   
--   For instance, <a>IconView</a> creates all icons (rows) to have the
--   same width and the cells theirin to have the same horizontal
--   alignments. However each row of icons may have a separate collective
--   height. <a>IconView</a> uses this to request the heights of each row
--   based on a context which was already used to request all the row
--   widths that are to be displayed.
--   
--   <i>Since: 3.0</i>
cellAreaCopyContext :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b) => a -> b -> m CellAreaContext

-- | Creates a <a>CellAreaContext</a> to be used with <i><tt>area</tt></i>
--   for all purposes. <a>CellAreaContext</a> stores geometry information
--   for rows for which it was operated on, it is important to use the same
--   context for the same row of data at all times (i.e. one should render
--   and handle events with the same <a>CellAreaContext</a> which was used
--   to request the size of those rows of data).
--   
--   <i>Since: 3.0</i>
cellAreaCreateContext :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m CellAreaContext

-- | Delegates event handling to a <a>CellArea</a>.
--   
--   <i>Since: 3.0</i>
cellAreaEvent :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Event -> Rectangle -> [CellRendererState] -> m Int32

-- | This should be called by the <i><tt>area</tt></i>’s owning layout
--   widget when focus is to be passed to <i><tt>area</tt></i>, or moved
--   within <i><tt>area</tt></i> for a given <i><tt>direction</tt></i> and
--   row data.
--   
--   Implementing <a>CellArea</a> classes should implement this method to
--   receive and navigate focus in its own way particular to how it lays
--   out cells.
--   
--   <i>Since: 3.0</i>
cellAreaFocus :: (HasCallStack, MonadIO m, IsCellArea a) => a -> DirectionType -> m Bool

-- | Derives the allocation of <i><tt>renderer</tt></i> inside
--   <i><tt>area</tt></i> if <i><tt>area</tt></i> were to be renderered in
--   <i><tt>cellArea</tt></i>.
--   
--   <i>Since: 3.0</i>
cellAreaGetCellAllocation :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c, IsCellRenderer d) => a -> b -> c -> d -> Rectangle -> m Rectangle

-- | Gets the <a>CellRenderer</a> at <i><tt>x</tt></i> and
--   <i><tt>y</tt></i> coordinates inside <i><tt>area</tt></i> and
--   optionally returns the full cell allocation for it inside
--   <i><tt>cellArea</tt></i>.
--   
--   <i>Since: 3.0</i>
cellAreaGetCellAtPosition :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Rectangle -> Int32 -> Int32 -> m (CellRenderer, Rectangle)

-- | Gets the current <a>TreePath</a> string for the currently applied
--   <a>TreeIter</a>, this is implicitly updated when
--   <a>cellAreaApplyAttributes</a> is called and can be used to interact
--   with renderers from <a>CellArea</a> subclasses.
--   
--   <i>Since: 3.0</i>
cellAreaGetCurrentPathString :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m Text

-- | Gets the <a>CellEditable</a> widget currently used to edit the
--   currently edited cell.
--   
--   <i>Since: 3.0</i>
cellAreaGetEditWidget :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m CellEditable

-- | Gets the <a>CellRenderer</a> in <i><tt>area</tt></i> that is currently
--   being edited.
--   
--   <i>Since: 3.0</i>
cellAreaGetEditedCell :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m CellRenderer

-- | Retrieves the currently focused cell for <i><tt>area</tt></i>
--   
--   <i>Since: 3.0</i>
cellAreaGetFocusCell :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m CellRenderer

-- | Gets the <a>CellRenderer</a> which is expected to be focusable for
--   which <i><tt>renderer</tt></i> is, or may be a sibling.
--   
--   This is handy for <a>CellArea</a> subclasses when handling events,
--   after determining the renderer at the event location it can then chose
--   to activate the focus cell for which the event cell may have been a
--   sibling.
--   
--   <i>Since: 3.0</i>
cellAreaGetFocusFromSibling :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m (Maybe CellRenderer)

-- | Gets the focus sibling cell renderers for <i><tt>renderer</tt></i>.
--   
--   <i>Since: 3.0</i>
cellAreaGetFocusSiblings :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m [CellRenderer]

-- | Retrieves a cell area’s minimum and natural width if it would be given
--   the specified <i><tt>height</tt></i>.
--   
--   <i><tt>area</tt></i> stores some geometrical information in
--   <i><tt>context</tt></i> along the way while calling
--   <a>cellAreaGetPreferredHeight</a>. It’s important to perform a series
--   of <a>cellAreaGetPreferredHeight</a> requests with
--   <i><tt>context</tt></i> first and then call
--   <a>cellAreaGetPreferredWidthForHeight</a> on each cell area
--   individually to get the height for width of each fully requested row.
--   
--   If at some point, the height of a single row changes, it should be
--   requested with <a>cellAreaGetPreferredHeight</a> again and then the
--   full height of the requested rows checked again with
--   <a>cellAreaContextGetPreferredHeight</a>.
--   
--   <i>Since: 3.0</i>
cellAreaGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Int32 -> m (Int32, Int32)

-- | Gets whether the area prefers a height-for-width layout or a
--   width-for-height layout.
--   
--   <i>Since: 3.0</i>
cellAreaGetRequestMode :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m SizeRequestMode

-- | Checks if <i><tt>area</tt></i> contains <i><tt>renderer</tt></i>.
--   
--   <i>Since: 3.0</i>
cellAreaHasRenderer :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m Bool

-- | This is a convenience function for <a>CellArea</a> implementations to
--   get the inner area where a given <a>CellRenderer</a> will be rendered.
--   It removes any padding previously added by
--   <a>cellAreaRequestRenderer</a>.
--   
--   <i>Since: 3.0</i>
cellAreaInnerCellArea :: (HasCallStack, MonadIO m, IsCellArea a, IsWidget b) => a -> b -> Rectangle -> m Rectangle

-- | Returns whether the area can do anything when activated, after
--   applying new attributes to <i><tt>area</tt></i>.
--   
--   <i>Since: 3.0</i>
cellAreaIsActivatable :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m Bool

-- | Returns whether <i><tt>sibling</tt></i> is one of
--   <i><tt>renderer</tt></i>’s focus siblings (see
--   <a>cellAreaAddFocusSibling</a>).
--   
--   <i>Since: 3.0</i>
cellAreaIsFocusSibling :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b, IsCellRenderer c) => a -> b -> c -> m Bool

-- | Removes <i><tt>renderer</tt></i> from <i><tt>area</tt></i>.
--   
--   <i>Since: 3.0</i>
cellAreaRemove :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m ()

-- | Removes <i><tt>sibling</tt></i> from <i><tt>renderer</tt></i>’s focus
--   sibling list (see <a>cellAreaAddFocusSibling</a>).
--   
--   <i>Since: 3.0</i>
cellAreaRemoveFocusSibling :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b, IsCellRenderer c) => a -> b -> c -> m ()

-- | Renders <i><tt>area</tt></i>’s cells according to
--   <i><tt>area</tt></i>’s layout onto <i><tt>widget</tt></i> at the given
--   coordinates.
--   
--   <i>Since: 3.0</i>
cellAreaRender :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Context -> Rectangle -> Rectangle -> [CellRendererState] -> Bool -> m ()

-- | This is a convenience function for <a>CellArea</a> implementations to
--   request size for cell renderers. It’s important to use this function
--   to request size and then use <a>cellAreaInnerCellArea</a> at render
--   and event time since this function will add padding around the cell
--   for focus painting.
--   
--   <i>Since: 3.0</i>
cellAreaRequestRenderer :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b, IsWidget c) => a -> b -> Orientation -> c -> Int32 -> m (Int32, Int32)

-- | Explicitly sets the currently focused cell to
--   <i><tt>renderer</tt></i>.
--   
--   This is generally called by implementations of
--   <a>CellAreaClass</a>.<tt><i>focus</i></tt>() or
--   <a>CellAreaClass</a>.<tt><i>event</i></tt>(), however it can also be
--   used to implement functions such as <a>treeViewSetCursorOnCell</a>.
--   
--   <i>Since: 3.0</i>
cellAreaSetFocusCell :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m ()

-- | Explicitly stops the editing of the currently edited cell.
--   
--   If <i><tt>canceled</tt></i> is <a>True</a>, the currently edited cell
--   renderer will emit the <a>editingCanceled</a> signal, otherwise the
--   the <a>editingDone</a> signal will be emitted on the current edit
--   widget.
--   
--   See <a>cellAreaGetEditedCell</a> and <a>cellAreaGetEditWidget</a>.
--   
--   <i>Since: 3.0</i>
cellAreaStopEditing :: (HasCallStack, MonadIO m, IsCellArea a) => a -> Bool -> m ()

-- | Adds an attribute mapping to the list in <i><tt>cellLayout</tt></i>.
--   
--   The <i><tt>column</tt></i> is the column of the model to get a value
--   from, and the <i><tt>attribute</tt></i> is the parameter on
--   <i><tt>cell</tt></i> to be set from the value. So for example if
--   column 2 of the model contains strings, you could have the “text”
--   attribute of a <a>CellRendererText</a> get its values from column 2.
--   
--   <i>Since: 2.4</i>
cellLayoutAddAttribute :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Text -> Int32 -> m ()

-- | Clears all existing attributes previously set with
--   <tt><i>gtk_cell_layout_set_attributes()</i></tt>.
--   
--   <i>Since: 2.4</i>
cellLayoutClearAttributes :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> m ()

-- | Returns the underlying <a>CellArea</a> which might be
--   <i><tt>cellLayout</tt></i> if called on a <a>CellArea</a> or might be
--   <a>Nothing</a> if no <a>CellArea</a> is used by
--   <i><tt>cellLayout</tt></i>.
--   
--   <i>Since: 3.0</i>
cellLayoutGetArea :: (HasCallStack, MonadIO m, IsCellLayout a) => a -> m (Maybe CellArea)

-- | Returns the cell renderers which have been added to
--   <i><tt>cellLayout</tt></i>.
--   
--   <i>Since: 2.12</i>
cellLayoutGetCells :: (HasCallStack, MonadIO m, IsCellLayout a) => a -> m [CellRenderer]

-- | Adds the <i><tt>cell</tt></i> to the end of
--   <i><tt>cellLayout</tt></i>. If <i><tt>expand</tt></i> is <a>False</a>,
--   then the <i><tt>cell</tt></i> is allocated no more space than it
--   needs. Any unused space is divided evenly between cells for which
--   <i><tt>expand</tt></i> is <a>True</a>.
--   
--   Note that reusing the same cell renderer is not supported.
--   
--   <i>Since: 2.4</i>
cellLayoutPackEnd :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Bool -> m ()

-- | Packs the <i><tt>cell</tt></i> into the beginning of
--   <i><tt>cellLayout</tt></i>. If <i><tt>expand</tt></i> is <a>False</a>,
--   then the <i><tt>cell</tt></i> is allocated no more space than it
--   needs. Any unused space is divided evenly between cells for which
--   <i><tt>expand</tt></i> is <a>True</a>.
--   
--   Note that reusing the same cell renderer is not supported.
--   
--   <i>Since: 2.4</i>
cellLayoutPackStart :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Bool -> m ()

-- | Re-inserts <i><tt>cell</tt></i> at <i><tt>position</tt></i>.
--   
--   Note that <i><tt>cell</tt></i> has already to be packed into
--   <i><tt>cellLayout</tt></i> for this to function properly.
--   
--   <i>Since: 2.4</i>
cellLayoutReorder :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Int32 -> m ()

-- | Connect a signal handler for the <a>columnsChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #columnsChanged callback
--   </pre>
onTreeViewColumnsChanged :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewColumnsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>columnsChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #columnsChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewColumnsChanged :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewColumnsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cursorChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #cursorChanged callback
--   </pre>
onTreeViewCursorChanged :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewCursorChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cursorChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #cursorChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewCursorChanged :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewCursorChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>expandCollapseCursorRow</a>
--   signal, to be run before the default handler. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #expandCollapseCursorRow callback
--   </pre>
onTreeViewExpandCollapseCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewExpandCollapseCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>expandCollapseCursorRow</a>
--   signal, to be run after the default handler. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #expandCollapseCursorRow callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewExpandCollapseCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewExpandCollapseCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #moveCursor callback
--   </pre>
onTreeViewMoveCursor :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeView #moveCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewMoveCursor :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowActivated</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #rowActivated callback
--   </pre>
onTreeViewRowActivated :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowActivated</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeView #rowActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewRowActivated :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowCollapsed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #rowCollapsed callback
--   </pre>
onTreeViewRowCollapsed :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowCollapsedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowCollapsed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeView #rowCollapsed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewRowCollapsed :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowCollapsedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowExpanded</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #rowExpanded callback
--   </pre>
onTreeViewRowExpanded :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowExpandedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowExpanded</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeView #rowExpanded callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewRowExpanded :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowExpandedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #selectAll callback
--   </pre>
onTreeViewSelectAll :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeView #selectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewSelectAll :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectCursorParent</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #selectCursorParent callback
--   </pre>
onTreeViewSelectCursorParent :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectCursorParentCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectCursorParent</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #selectCursorParent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewSelectCursorParent :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectCursorParentCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectCursorRow</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #selectCursorRow callback
--   </pre>
onTreeViewSelectCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectCursorRow</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #selectCursorRow callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewSelectCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>startInteractiveSearch</a> signal,
--   to be run before the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #startInteractiveSearch callback
--   </pre>
onTreeViewStartInteractiveSearch :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewStartInteractiveSearchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>startInteractiveSearch</a> signal,
--   to be run after the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #startInteractiveSearch callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewStartInteractiveSearch :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewStartInteractiveSearchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>testCollapseRow</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #testCollapseRow callback
--   </pre>
onTreeViewTestCollapseRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewTestCollapseRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>testCollapseRow</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #testCollapseRow callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewTestCollapseRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewTestCollapseRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>testExpandRow</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #testExpandRow callback
--   </pre>
onTreeViewTestExpandRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewTestExpandRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>testExpandRow</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #testExpandRow callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewTestExpandRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewTestExpandRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleCursorRow</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #toggleCursorRow callback
--   </pre>
onTreeViewToggleCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewToggleCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleCursorRow</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #toggleCursorRow callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewToggleCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewToggleCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unselectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #unselectAll callback
--   </pre>
onTreeViewUnselectAll :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewUnselectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unselectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeView #unselectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewUnselectAll :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewUnselectAllCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>activate-on-single-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #activateOnSingleClick
--   </pre>
getTreeViewActivateOnSingleClick :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>activate-on-single-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #activateOnSingleClick <a>:=</a> value ]
--   </pre>
setTreeViewActivateOnSingleClick :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activate-on-single-click</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTreeViewActivateOnSingleClick :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>enable-grid-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #enableGridLines
--   </pre>
getTreeViewEnableGridLines :: (MonadIO m, IsTreeView o) => o -> m TreeViewGridLines

-- | Set the value of the “<tt>enable-grid-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #enableGridLines <a>:=</a> value ]
--   </pre>
setTreeViewEnableGridLines :: (MonadIO m, IsTreeView o) => o -> TreeViewGridLines -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-grid-lines</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewEnableGridLines :: (IsTreeView o, MonadIO m) => TreeViewGridLines -> m (GValueConstruct o)

-- | Get the value of the “<tt>enable-search</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #enableSearch
--   </pre>
getTreeViewEnableSearch :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>enable-search</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #enableSearch <a>:=</a> value ]
--   </pre>
setTreeViewEnableSearch :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-search</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeViewEnableSearch :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>enable-tree-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #enableTreeLines
--   </pre>
getTreeViewEnableTreeLines :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>enable-tree-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #enableTreeLines <a>:=</a> value ]
--   </pre>
setTreeViewEnableTreeLines :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-tree-lines</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewEnableTreeLines :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>expander-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #expanderColumn
--   </pre>
getTreeViewExpanderColumn :: (MonadIO m, IsTreeView o) => o -> m TreeViewColumn

-- | Set the value of the “<tt>expander-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #expanderColumn <a>:=</a> value ]
--   </pre>
setTreeViewExpanderColumn :: (MonadIO m, IsTreeView o, IsTreeViewColumn a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>expander-column</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewExpanderColumn :: (IsTreeView o, MonadIO m, IsTreeViewColumn a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>expander-column</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #expanderColumn
--   </pre>
clearTreeViewExpanderColumn :: (MonadIO m, IsTreeView o) => o -> m ()

-- | Get the value of the “<tt>fixed-height-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #fixedHeightMode
--   </pre>
getTreeViewFixedHeightMode :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>fixed-height-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #fixedHeightMode <a>:=</a> value ]
--   </pre>
setTreeViewFixedHeightMode :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fixed-height-mode</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewFixedHeightMode :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>headers-clickable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #headersClickable
--   </pre>
getTreeViewHeadersClickable :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>headers-clickable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #headersClickable <a>:=</a> value ]
--   </pre>
setTreeViewHeadersClickable :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>headers-clickable</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewHeadersClickable :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>headers-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #headersVisible
--   </pre>
getTreeViewHeadersVisible :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>headers-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #headersVisible <a>:=</a> value ]
--   </pre>
setTreeViewHeadersVisible :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>headers-visible</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewHeadersVisible :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>hover-expand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #hoverExpand
--   </pre>
getTreeViewHoverExpand :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>hover-expand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #hoverExpand <a>:=</a> value ]
--   </pre>
setTreeViewHoverExpand :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hover-expand</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeViewHoverExpand :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>hover-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #hoverSelection
--   </pre>
getTreeViewHoverSelection :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>hover-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #hoverSelection <a>:=</a> value ]
--   </pre>
setTreeViewHoverSelection :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hover-selection</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewHoverSelection :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>level-indentation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #levelIndentation
--   </pre>
getTreeViewLevelIndentation :: (MonadIO m, IsTreeView o) => o -> m Int32

-- | Set the value of the “<tt>level-indentation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #levelIndentation <a>:=</a> value ]
--   </pre>
setTreeViewLevelIndentation :: (MonadIO m, IsTreeView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>level-indentation</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewLevelIndentation :: (IsTreeView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #model
--   </pre>
getTreeViewModel :: (MonadIO m, IsTreeView o) => o -> m (Maybe TreeModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #model <a>:=</a> value ]
--   </pre>
setTreeViewModel :: (MonadIO m, IsTreeView o, IsTreeModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeViewModel :: (IsTreeView o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearTreeViewModel :: (MonadIO m, IsTreeView o) => o -> m ()

-- | Get the value of the “<tt>reorderable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #reorderable
--   </pre>
getTreeViewReorderable :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>reorderable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #reorderable <a>:=</a> value ]
--   </pre>
setTreeViewReorderable :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>reorderable</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeViewReorderable :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>rubber-banding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #rubberBanding
--   </pre>
getTreeViewRubberBanding :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>rubber-banding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #rubberBanding <a>:=</a> value ]
--   </pre>
setTreeViewRubberBanding :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rubber-banding</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewRubberBanding :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>rules-hint</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #rulesHint
--   </pre>
getTreeViewRulesHint :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>rules-hint</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #rulesHint <a>:=</a> value ]
--   </pre>
setTreeViewRulesHint :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rules-hint</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeViewRulesHint :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>search-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #searchColumn
--   </pre>
getTreeViewSearchColumn :: (MonadIO m, IsTreeView o) => o -> m Int32

-- | Set the value of the “<tt>search-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #searchColumn <a>:=</a> value ]
--   </pre>
setTreeViewSearchColumn :: (MonadIO m, IsTreeView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>search-column</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeViewSearchColumn :: (IsTreeView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-expanders</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #showExpanders
--   </pre>
getTreeViewShowExpanders :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>show-expanders</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #showExpanders <a>:=</a> value ]
--   </pre>
setTreeViewShowExpanders :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-expanders</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewShowExpanders :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>tooltip-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #tooltipColumn
--   </pre>
getTreeViewTooltipColumn :: (MonadIO m, IsTreeView o) => o -> m Int32

-- | Set the value of the “<tt>tooltip-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #tooltipColumn <a>:=</a> value ]
--   </pre>
setTreeViewTooltipColumn :: (MonadIO m, IsTreeView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip-column</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewTooltipColumn :: (IsTreeView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new <a>TreeView</a> widget.
treeViewNew :: (HasCallStack, MonadIO m) => m TreeView

-- | Creates a new <a>TreeView</a> widget with the model initialized to
--   <i><tt>model</tt></i>.
treeViewNewWithModel :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m TreeView

-- | Appends <i><tt>column</tt></i> to the list of columns. If
--   <i><tt>treeView</tt></i> has “fixed_height” mode enabled, then
--   <i><tt>column</tt></i> must have its “sizing” property set to be
--   GTK_TREE_VIEW_COLUMN_FIXED.
treeViewAppendColumn :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> b -> m Int32

-- | Recursively collapses all visible, expanded nodes in
--   <i><tt>treeView</tt></i>.
treeViewCollapseAll :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m ()

-- | Collapses a row (hides its child rows, if they exist).
treeViewCollapseRow :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreePath -> m Bool

-- | Resizes all columns to their optimal width. Only works after the
--   treeview has been realized.
treeViewColumnsAutosize :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m ()

-- | Converts bin_window coordinates to coordinates for the tree (the full
--   scrollable area of the tree).
--   
--   <i>Since: 2.12</i>
treeViewConvertBinWindowToTreeCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Converts bin_window coordinates (see <a>treeViewGetBinWindow</a>) to
--   widget relative coordinates.
--   
--   <i>Since: 2.12</i>
treeViewConvertBinWindowToWidgetCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Converts tree coordinates (coordinates in full scrollable area of the
--   tree) to bin_window coordinates.
--   
--   <i>Since: 2.12</i>
treeViewConvertTreeToBinWindowCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Converts tree coordinates (coordinates in full scrollable area of the
--   tree) to widget coordinates.
--   
--   <i>Since: 2.12</i>
treeViewConvertTreeToWidgetCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Converts widget coordinates to coordinates for the bin_window (see
--   <a>treeViewGetBinWindow</a>).
--   
--   <i>Since: 2.12</i>
treeViewConvertWidgetToBinWindowCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Converts widget coordinates to coordinates for the tree (the full
--   scrollable area of the tree).
--   
--   <i>Since: 2.12</i>
treeViewConvertWidgetToTreeCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Creates a <a>Surface</a> representation of the row at
--   <i><tt>path</tt></i>. This image is used for a drag icon.
treeViewCreateRowDragIcon :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreePath -> m Surface

-- | Turns <i><tt>treeView</tt></i> into a drop destination for automatic
--   DND. Calling this method sets <a>TreeView:reorderable</a> to
--   <a>False</a>.
treeViewEnableModelDragDest :: (HasCallStack, MonadIO m, IsTreeView a) => a -> [TargetEntry] -> [DragAction] -> m ()

-- | Turns <i><tt>treeView</tt></i> into a drag source for automatic DND.
--   Calling this method sets <a>TreeView:reorderable</a> to <a>False</a>.
treeViewEnableModelDragSource :: (HasCallStack, MonadIO m, IsTreeView a) => a -> [ModifierType] -> [TargetEntry] -> [DragAction] -> m ()

-- | Recursively expands all nodes in the <i><tt>treeView</tt></i>.
treeViewExpandAll :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m ()

-- | Opens the row so its children are visible.
treeViewExpandRow :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreePath -> Bool -> m Bool

-- | Expands the row at <i><tt>path</tt></i>. This will also expand all
--   parent rows of <i><tt>path</tt></i> as necessary.
--   
--   <i>Since: 2.2</i>
treeViewExpandToPath :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreePath -> m ()

-- | Gets the setting set by <a>treeViewSetActivateOnSingleClick</a>.
--   
--   <i>Since: 3.8</i>
treeViewGetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Fills the bounding rectangle in bin_window coordinates for the cell at
--   the row specified by <i><tt>path</tt></i> and the column specified by
--   <i><tt>column</tt></i>. If <i><tt>path</tt></i> is <a>Nothing</a>, or
--   points to a node not found in the tree, the <i><tt>y</tt></i> and
--   <i><tt>height</tt></i> fields of the rectangle will be filled with 0.
--   If <i><tt>column</tt></i> is <a>Nothing</a>, the <i><tt>x</tt></i> and
--   <i><tt>width</tt></i> fields will be filled with 0. The returned
--   rectangle is equivalent to the <i><tt>backgroundArea</tt></i> passed
--   to <a>cellRendererRender</a>. These background areas tile to cover the
--   entire bin window. Contrast with the <i><tt>cellArea</tt></i>,
--   returned by <a>treeViewGetCellArea</a>, which returns only the cell
--   itself, excluding surrounding borders and the tree expander area.
treeViewGetBackgroundArea :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> Maybe TreePath -> Maybe b -> m Rectangle

-- | Returns the window that <i><tt>treeView</tt></i> renders to. This is
--   used primarily to compare to <tt>event-&gt;window</tt> to confirm that
--   the event on <i><tt>treeView</tt></i> is on the right window.
treeViewGetBinWindow :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Maybe Window)

-- | Fills the bounding rectangle in bin_window coordinates for the cell at
--   the row specified by <i><tt>path</tt></i> and the column specified by
--   <i><tt>column</tt></i>. If <i><tt>path</tt></i> is <a>Nothing</a>, or
--   points to a path not currently displayed, the <i><tt>y</tt></i> and
--   <i><tt>height</tt></i> fields of the rectangle will be filled with 0.
--   If <i><tt>column</tt></i> is <a>Nothing</a>, the <i><tt>x</tt></i> and
--   <i><tt>width</tt></i> fields will be filled with 0. The sum of all
--   cell rects does not cover the entire tree; there are extra pixels in
--   between rows, for example. The returned rectangle is equivalent to the
--   <i><tt>cellArea</tt></i> passed to <a>cellRendererRender</a>. This
--   function is only valid if <i><tt>treeView</tt></i> is realized.
treeViewGetCellArea :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> Maybe TreePath -> Maybe b -> m Rectangle

-- | Gets the <a>TreeViewColumn</a> at the given position in the
--   <tt><i>tree_view</i></tt>.
treeViewGetColumn :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> m (Maybe TreeViewColumn)

-- | Returns a <a>List</a> of all the <a>TreeViewColumn</a> s currently in
--   <i><tt>treeView</tt></i>. The returned list must be freed with
--   g_list_free ().
treeViewGetColumns :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m [TreeViewColumn]

-- | Fills in <i><tt>path</tt></i> and <i><tt>focusColumn</tt></i> with the
--   current path and focus column. If the cursor isn’t currently set, then
--   *<i><tt>path</tt></i> will be <a>Nothing</a>. If no column currently
--   has focus, then *<i><tt>focusColumn</tt></i> will be <a>Nothing</a>.
--   
--   The returned <a>TreePath</a> must be freed with <a>treePathFree</a>
--   when you are done with it.
treeViewGetCursor :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Maybe TreePath, Maybe TreeViewColumn)

-- | Determines the destination row for a given position.
--   <i><tt>dragX</tt></i> and <i><tt>dragY</tt></i> are expected to be in
--   widget coordinates. This function is only meaningful if
--   <i><tt>treeView</tt></i> is realized. Therefore this function will
--   always return <a>False</a> if <i><tt>treeView</tt></i> is not realized
--   or does not have a model.
treeViewGetDestRowAtPos :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Bool, Maybe TreePath, TreeViewDropPosition)

-- | Gets information about the row that is highlighted for feedback.
treeViewGetDragDestRow :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Maybe TreePath, TreeViewDropPosition)

-- | Returns whether or not the tree allows to start interactive searching
--   by typing in text.
treeViewGetEnableSearch :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns whether or not tree lines are drawn in
--   <i><tt>treeView</tt></i>.
--   
--   <i>Since: 2.10</i>
treeViewGetEnableTreeLines :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns the column that is the current expander column. This column
--   has the expander arrow drawn next to it.
treeViewGetExpanderColumn :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m TreeViewColumn

-- | Returns whether fixed height mode is turned on for
--   <i><tt>treeView</tt></i>.
--   
--   <i>Since: 2.6</i>
treeViewGetFixedHeightMode :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns which grid lines are enabled in <i><tt>treeView</tt></i>.
--   
--   <i>Since: 2.10</i>
treeViewGetGridLines :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m TreeViewGridLines

-- | Gets the <a>Adjustment</a> currently being used for the horizontal
--   aspect.
treeViewGetHadjustment :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Adjustment

-- | Returns whether all header columns are clickable.
--   
--   <i>Since: 2.10</i>
treeViewGetHeadersClickable :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns <a>True</a> if the headers on the <i><tt>treeView</tt></i> are
--   visible.
treeViewGetHeadersVisible :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns whether hover expansion mode is turned on for
--   <i><tt>treeView</tt></i>.
--   
--   <i>Since: 2.6</i>
treeViewGetHoverExpand :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns whether hover selection mode is turned on for
--   <i><tt>treeView</tt></i>.
--   
--   <i>Since: 2.6</i>
treeViewGetHoverSelection :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns the amount, in pixels, of extra indentation for child levels
--   in <i><tt>treeView</tt></i>.
--   
--   <i>Since: 2.12</i>
treeViewGetLevelIndentation :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Int32

-- | Returns the model the <a>TreeView</a> is based on. Returns
--   <a>Nothing</a> if the model is unset.
treeViewGetModel :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Maybe TreeModel)

-- | Queries the number of columns in the given <i><tt>treeView</tt></i>.
--   
--   <i>Since: 3.4</i>
treeViewGetNColumns :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Word32

-- | Finds the path at the point (<i><tt>x</tt></i>, <i><tt>y</tt></i>),
--   relative to bin_window coordinates (please see
--   <a>treeViewGetBinWindow</a>). That is, <i><tt>x</tt></i> and
--   <i><tt>y</tt></i> are relative to an events coordinates.
--   <i><tt>x</tt></i> and <i><tt>y</tt></i> must come from an event on the
--   <i><tt>treeView</tt></i> only where <tt>event-&gt;window ==
--   gtk_tree_view_get_bin_window ()</tt>. It is primarily for things like
--   popup menus. If <i><tt>path</tt></i> is non-<a>Nothing</a>, then it
--   will be filled with the <a>TreePath</a> at that point. This path
--   should be freed with <a>treePathFree</a>. If <i><tt>column</tt></i> is
--   non-<a>Nothing</a>, then it will be filled with the column at that
--   point. <i><tt>cellX</tt></i> and <i><tt>cellY</tt></i> return the
--   coordinates relative to the cell background (i.e. the
--   <i><tt>backgroundArea</tt></i> passed to <a>cellRendererRender</a>).
--   This function is only meaningful if <i><tt>treeView</tt></i> is
--   realized. Therefore this function will always return <a>False</a> if
--   <i><tt>treeView</tt></i> is not realized or does not have a model.
--   
--   For converting widget coordinates (eg. the ones you get from
--   GtkWidget<a>queryTooltip</a>), please see
--   <a>treeViewConvertWidgetToBinWindowCoords</a>.
treeViewGetPathAtPos :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Bool, Maybe TreePath, Maybe TreeViewColumn, Int32, Int32)

-- | Retrieves whether the user can reorder the tree via drag-and-drop. See
--   <a>treeViewSetReorderable</a>.
treeViewGetReorderable :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns whether rubber banding is turned on for
--   <i><tt>treeView</tt></i>. If the selection mode is
--   <tt><i>GTK_SELECTION_MULTIPLE</i></tt>, rubber banding will allow the
--   user to select multiple rows by dragging the mouse.
--   
--   <i>Since: 2.10</i>
treeViewGetRubberBanding :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Gets the setting set by <a>treeViewSetRulesHint</a>.
treeViewGetRulesHint :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Gets the column searched on by the interactive search code.
treeViewGetSearchColumn :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Int32

-- | Returns the <a>Entry</a> which is currently in use as interactive
--   search entry for <i><tt>treeView</tt></i>. In case the built-in entry
--   is being used, <a>Nothing</a> will be returned.
--   
--   <i>Since: 2.10</i>
treeViewGetSearchEntry :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Entry

-- | Gets the <a>TreeSelection</a> associated with
--   <i><tt>treeView</tt></i>.
treeViewGetSelection :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m TreeSelection

-- | Returns whether or not expanders are drawn in
--   <i><tt>treeView</tt></i>.
--   
--   <i>Since: 2.12</i>
treeViewGetShowExpanders :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns the column of <i><tt>treeView</tt></i>’s model which is being
--   used for displaying tooltips on <i><tt>treeView</tt></i>’s rows.
--   
--   <i>Since: 2.12</i>
treeViewGetTooltipColumn :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Int32

-- | This function is supposed to be used in a <a>Widget::queryTooltip</a>
--   signal handler for <a>TreeView</a>. The <i><tt>x</tt></i>,
--   <i><tt>y</tt></i> and <i><tt>keyboardTip</tt></i> values which are
--   received in the signal handler, should be passed to this function
--   without modification.
--   
--   The return value indicates whether there is a tree view row at the
--   given coordinates (<a>True</a>) or not (<a>False</a>) for mouse
--   tooltips. For keyboard tooltips the row returned will be the cursor
--   row. When <a>True</a>, then any of <i><tt>model</tt></i>,
--   <i><tt>path</tt></i> and <i><tt>iter</tt></i> which have been provided
--   will be set to point to that row and the corresponding model.
--   <i><tt>x</tt></i> and <i><tt>y</tt></i> will always be converted to be
--   relative to <i><tt>treeView</tt></i>’s bin_window if
--   <i><tt>keyboardTooltip</tt></i> is <a>False</a>.
--   
--   <i>Since: 2.12</i>
treeViewGetTooltipContext :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> Bool -> m (Bool, Int32, Int32, Maybe TreeModel, TreePath, TreeIter)

-- | Gets the <a>Adjustment</a> currently being used for the vertical
--   aspect.
treeViewGetVadjustment :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Adjustment

-- | Sets <i><tt>startPath</tt></i> and <i><tt>endPath</tt></i> to be the
--   first and last visible path. Note that there may be invisible paths in
--   between.
--   
--   The paths should be freed with <a>treePathFree</a> after use.
--   
--   <i>Since: 2.8</i>
treeViewGetVisibleRange :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Bool, TreePath, TreePath)

-- | Fills <i><tt>visibleRect</tt></i> with the currently-visible region of
--   the buffer, in tree coordinates. Convert to bin_window coordinates
--   with <a>treeViewConvertTreeToBinWindowCoords</a>. Tree coordinates
--   start at 0,0 for row 0 of the tree, and cover the entire scrollable
--   area of the tree.
treeViewGetVisibleRect :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Rectangle

-- | This inserts the <i><tt>column</tt></i> into the
--   <i><tt>treeView</tt></i> at <i><tt>position</tt></i>. If
--   <i><tt>position</tt></i> is -1, then the column is inserted at the
--   end. If <i><tt>treeView</tt></i> has “fixed_height” mode enabled, then
--   <i><tt>column</tt></i> must have its “sizing” property set to be
--   GTK_TREE_VIEW_COLUMN_FIXED.
treeViewInsertColumn :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> b -> Int32 -> m Int32

-- | Convenience function that inserts a new column into the
--   <a>TreeView</a> with the given cell renderer and a
--   <a>TreeCellDataFunc</a> to set cell renderer attributes (normally
--   using data from the model). See also
--   <a>treeViewColumnSetCellDataFunc</a>, <a>treeViewColumnPackStart</a>.
--   If <i><tt>treeView</tt></i> has “fixed_height” mode enabled, then the
--   new column will have its “sizing” property set to be
--   GTK_TREE_VIEW_COLUMN_FIXED.
treeViewInsertColumnWithDataFunc :: (HasCallStack, MonadIO m, IsTreeView a, IsCellRenderer b) => a -> Int32 -> Text -> b -> TreeCellDataFunc -> m Int32

-- | Determine whether the point (<i><tt>x</tt></i>, <i><tt>y</tt></i>) in
--   <i><tt>treeView</tt></i> is blank, that is no cell content nor an
--   expander arrow is drawn at the location. If so, the location can be
--   considered as the background. You might wish to take special action on
--   clicks on the background, such as clearing a current selection, having
--   a custom context menu or starting rubber banding.
--   
--   The <i><tt>x</tt></i> and <i><tt>y</tt></i> coordinate that are
--   provided must be relative to bin_window coordinates. That is,
--   <i><tt>x</tt></i> and <i><tt>y</tt></i> must come from an event on
--   <i><tt>treeView</tt></i> where <tt>event-&gt;window ==
--   gtk_tree_view_get_bin_window ()</tt>.
--   
--   For converting widget coordinates (eg. the ones you get from
--   GtkWidget<a>queryTooltip</a>), please see
--   <a>treeViewConvertWidgetToBinWindowCoords</a>.
--   
--   The <i><tt>path</tt></i>, <i><tt>column</tt></i>,
--   <i><tt>cellX</tt></i> and <i><tt>cellY</tt></i> arguments will be
--   filled in likewise as for <a>treeViewGetPathAtPos</a>. Please see
--   <a>treeViewGetPathAtPos</a> for more information.
--   
--   <i>Since: 3.0</i>
treeViewIsBlankAtPos :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Bool, Maybe TreePath, Maybe TreeViewColumn, Int32, Int32)

-- | Returns whether a rubber banding operation is currently being done in
--   <i><tt>treeView</tt></i>.
--   
--   <i>Since: 2.12</i>
treeViewIsRubberBandingActive :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Moves <i><tt>column</tt></i> to be after to
--   <i><tt>baseColumn</tt></i>. If <i><tt>baseColumn</tt></i> is
--   <a>Nothing</a>, then <i><tt>column</tt></i> is placed in the first
--   position.
treeViewMoveColumnAfter :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsTreeViewColumn c) => a -> b -> Maybe c -> m ()

-- | Removes <i><tt>column</tt></i> from <i><tt>treeView</tt></i>.
treeViewRemoveColumn :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> b -> m Int32

-- | Activates the cell determined by <i><tt>path</tt></i> and
--   <i><tt>column</tt></i>.
treeViewRowActivated :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> TreePath -> b -> m ()

-- | Returns <a>True</a> if the node pointed to by <i><tt>path</tt></i> is
--   expanded in <i><tt>treeView</tt></i>.
treeViewRowExpanded :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreePath -> m Bool

-- | Moves the alignments of <i><tt>treeView</tt></i> to the position
--   specified by <i><tt>column</tt></i> and <i><tt>path</tt></i>. If
--   <i><tt>column</tt></i> is <a>Nothing</a>, then no horizontal scrolling
--   occurs. Likewise, if <i><tt>path</tt></i> is <a>Nothing</a> no
--   vertical scrolling occurs. At a minimum, one of <i><tt>column</tt></i>
--   or <i><tt>path</tt></i> need to be non-<a>Nothing</a>.
--   <i><tt>rowAlign</tt></i> determines where the row is placed, and
--   <i><tt>colAlign</tt></i> determines where <i><tt>column</tt></i> is
--   placed. Both are expected to be between 0.0 and 1.0. 0.0 means
--   left/top alignment, 1.0 means right/bottom alignment, 0.5 means
--   center.
--   
--   If <i><tt>useAlign</tt></i> is <a>False</a>, then the alignment
--   arguments are ignored, and the tree does the minimum amount of work to
--   scroll the cell onto the screen. This means that the cell will be
--   scrolled to the edge closest to its current position. If the cell is
--   currently visible on the screen, nothing is done.
--   
--   This function only works if the model is set, and <i><tt>path</tt></i>
--   is a valid row on the model. If the model changes before the
--   <i><tt>treeView</tt></i> is realized, the centered path will be
--   modified to reflect this change.
treeViewScrollToCell :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> Maybe TreePath -> Maybe b -> Bool -> Float -> Float -> m ()

-- | Scrolls the tree view such that the top-left corner of the visible
--   area is <i><tt>treeX</tt></i>, <i><tt>treeY</tt></i>, where
--   <i><tt>treeX</tt></i> and <i><tt>treeY</tt></i> are specified in tree
--   coordinates. The <i><tt>treeView</tt></i> must be realized before this
--   function is called. If it isn't, you probably want to be using
--   <a>treeViewScrollToCell</a>.
--   
--   If either <i><tt>treeX</tt></i> or <i><tt>treeY</tt></i> are -1, then
--   that direction isn’t scrolled.
treeViewScrollToPoint :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m ()

-- | Cause the <a>TreeView::rowActivated</a> signal to be emitted on a
--   single click instead of a double click.
--   
--   <i>Since: 3.8</i>
treeViewSetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets a user function for determining where a column may be dropped
--   when dragged. This function is called on every column pair in turn at
--   the beginning of a column drag to determine where a drop can take
--   place. The arguments passed to <i><tt>func</tt></i> are: the
--   <i><tt>treeView</tt></i>, the <a>TreeViewColumn</a> being dragged, the
--   two <a>TreeViewColumn</a> s determining the drop spot, and
--   <i><tt>userData</tt></i>. If either of the <a>TreeViewColumn</a>
--   arguments for the drop spot are <a>Nothing</a>, then they indicate an
--   edge. If <i><tt>func</tt></i> is set to be <a>Nothing</a>, then
--   <i><tt>treeView</tt></i> reverts to the default behavior of allowing
--   all columns to be dropped everywhere.
treeViewSetColumnDragFunction :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreeViewColumnDropFunc -> m ()

-- | Sets the current keyboard focus to be at <i><tt>path</tt></i>, and
--   selects it. This is useful when you want to focus the user’s attention
--   on a particular row. If <i><tt>focusColumn</tt></i> is not
--   <a>Nothing</a>, then focus is given to the column specified by it.
--   Additionally, if <i><tt>focusColumn</tt></i> is specified, and
--   <i><tt>startEditing</tt></i> is <a>True</a>, then editing should be
--   started in the specified cell. This function is often followed by
--   <i><tt>gtkWidgetGrabFocus</tt></i> (<i><tt>treeView</tt></i>) in order
--   to give keyboard focus to the widget. Please note that editing can
--   only happen when the widget is realized.
--   
--   If <i><tt>path</tt></i> is invalid for <i><tt>model</tt></i>, the
--   current cursor (if any) will be unset and the function will return
--   without failing.
treeViewSetCursor :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> TreePath -> Maybe b -> Bool -> m ()

-- | This function should almost never be used. It is meant for private use
--   by ATK for determining the number of visible children that are removed
--   when the user collapses a row, or a row is deleted.
treeViewSetDestroyCountFunc :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreeDestroyCountFunc -> m ()

-- | Sets the row that is highlighted for feedback. If <i><tt>path</tt></i>
--   is <a>Nothing</a>, an existing highlight is removed.
treeViewSetDragDestRow :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreePath -> TreeViewDropPosition -> m ()

-- | If <i><tt>enableSearch</tt></i> is set, then the user can type in text
--   to search through the tree interactively (this is sometimes called
--   "typeahead find").
--   
--   Note that even if this is <a>False</a>, the user can still initiate a
--   search using the “start-interactive-search” key binding.
treeViewSetEnableSearch :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets whether to draw lines interconnecting the expanders in
--   <i><tt>treeView</tt></i>. This does not have any visible effects for
--   lists.
--   
--   <i>Since: 2.10</i>
treeViewSetEnableTreeLines :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets the column to draw the expander arrow at. It must be in
--   <i><tt>treeView</tt></i>. If <i><tt>column</tt></i> is <a>Nothing</a>,
--   then the expander arrow is always at the first visible column.
--   
--   If you do not want expander arrow to appear in your tree, set the
--   expander column to a hidden column.
treeViewSetExpanderColumn :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> Maybe b -> m ()

-- | Enables or disables the fixed height mode of <i><tt>treeView</tt></i>.
--   Fixed height mode speeds up <a>TreeView</a> by assuming that all rows
--   have the same height. Only enable this option if all rows are the same
--   height and all columns are of type <a>TreeViewColumnSizingFixed</a>.
--   
--   <i>Since: 2.6</i>
treeViewSetFixedHeightMode :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets which grid lines to draw in <i><tt>treeView</tt></i>.
--   
--   <i>Since: 2.10</i>
treeViewSetGridLines :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreeViewGridLines -> m ()

-- | Sets the <a>Adjustment</a> for the current horizontal aspect.
treeViewSetHadjustment :: (HasCallStack, MonadIO m, IsTreeView a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Allow the column title buttons to be clicked.
treeViewSetHeadersClickable :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets the visibility state of the headers.
treeViewSetHeadersVisible :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Enables or disables the hover expansion mode of
--   <i><tt>treeView</tt></i>. Hover expansion makes rows expand or
--   collapse if the pointer moves over them.
--   
--   <i>Since: 2.6</i>
treeViewSetHoverExpand :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Enables or disables the hover selection mode of
--   <i><tt>treeView</tt></i>. Hover selection makes the selected row
--   follow the pointer. Currently, this works only for the selection modes
--   <a>SelectionModeSingle</a> and <a>SelectionModeBrowse</a>.
--   
--   <i>Since: 2.6</i>
treeViewSetHoverSelection :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets the amount of extra indentation for child levels to use in
--   <i><tt>treeView</tt></i> in addition to the default indentation. The
--   value should be specified in pixels, a value of 0 disables this
--   feature and in this case only the default indentation will be used.
--   This does not have any visible effects for lists.
--   
--   <i>Since: 2.12</i>
treeViewSetLevelIndentation :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> m ()

-- | Sets the model for a <a>TreeView</a>. If the <i><tt>treeView</tt></i>
--   already has a model set, it will remove it before setting the new
--   model. If <i><tt>model</tt></i> is <a>Nothing</a>, then it will unset
--   the old model.
treeViewSetModel :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeModel b) => a -> Maybe b -> m ()

-- | This function is a convenience function to allow you to reorder models
--   that support the <a>TreeDragSourceIface</a> and the
--   <a>TreeDragDestIface</a>. Both <a>TreeStore</a> and <a>ListStore</a>
--   support these. If <i><tt>reorderable</tt></i> is <a>True</a>, then the
--   user can reorder the model by dragging and dropping rows. The
--   developer can listen to these changes by connecting to the model’s
--   <a>TreeModel::rowInserted</a> and <a>TreeModel::rowDeleted</a>
--   signals. The reordering is implemented by setting up the tree view as
--   a drag source and destination. Therefore, drag and drop can not be
--   used in a reorderable view for any other purpose.
--   
--   This function does not give you any degree of control over the order
--   -- any reordering is allowed. If more control is needed, you should
--   probably handle drag and drop manually.
treeViewSetReorderable :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets the row separator function, which is used to determine whether a
--   row should be drawn as a separator. If the row separator function is
--   <a>Nothing</a>, no separators are drawn. This is the default value.
--   
--   <i>Since: 2.6</i>
treeViewSetRowSeparatorFunc :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreeViewRowSeparatorFunc -> m ()

-- | Enables or disables rubber banding in <i><tt>treeView</tt></i>. If the
--   selection mode is <tt><i>GTK_SELECTION_MULTIPLE</i></tt>, rubber
--   banding will allow the user to select multiple rows by dragging the
--   mouse.
--   
--   <i>Since: 2.10</i>
treeViewSetRubberBanding :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets a hint for the theme to draw even/odd rows in the
--   <i><tt>treeView</tt></i> with different colors, also known as "zebra
--   striping".
--   
--   This function tells the GTK+ theme that the user interface for your
--   application requires users to read across tree rows and associate
--   cells with one another.
--   
--   Do not use it just because you prefer the appearance of the ruled
--   tree; that’s a question for the theme. Some themes will draw tree rows
--   in alternating colors even when rules are turned off, and users who
--   prefer that appearance all the time can choose those themes. You
--   should call this function only as a semantic hint to the theme engine
--   that your tree makes alternating colors useful from a functional
--   standpoint (since it has lots of columns, generally).
treeViewSetRulesHint :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets the entry which the interactive search code will use for this
--   <i><tt>treeView</tt></i>. This is useful when you want to provide a
--   search entry in our interface at all time at a fixed position. Passing
--   <a>Nothing</a> for <i><tt>entry</tt></i> will make the interactive
--   search code use the built-in popup entry again.
--   
--   <i>Since: 2.10</i>
treeViewSetSearchEntry :: (HasCallStack, MonadIO m, IsTreeView a, IsEntry b) => a -> Maybe b -> m ()

-- | Sets the function to use when positioning the search dialog.
--   
--   <i>Since: 2.10</i>
treeViewSetSearchPositionFunc :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreeViewSearchPositionFunc -> m ()

-- | Sets whether to draw and enable expanders and indent child rows in
--   <i><tt>treeView</tt></i>. When disabled there will be no expanders
--   visible in trees and there will be no way to expand and collapse rows
--   by default. Also note that hiding the expanders will disable the
--   default indentation. You can set a custom indentation in this case
--   using <a>treeViewSetLevelIndentation</a>. This does not have any
--   visible effects for lists.
--   
--   <i>Since: 2.12</i>
treeViewSetShowExpanders :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | If you only plan to have simple (text-only) tooltips on full rows, you
--   can use this function to have <a>TreeView</a> handle these
--   automatically for you. <i><tt>column</tt></i> should be set to the
--   column in <i><tt>treeView</tt></i>’s model containing the tooltip
--   texts, or -1 to disable this feature.
--   
--   When enabled, <a>Widget:hasTooltip</a> will be set to <a>True</a> and
--   <i><tt>treeView</tt></i> will connect a <a>Widget::queryTooltip</a>
--   signal handler.
--   
--   Note that the signal handler sets the text with
--   <a>tooltipSetMarkup</a>, so &amp;, &lt;, etc have to be escaped in the
--   text.
--   
--   <i>Since: 2.12</i>
treeViewSetTooltipColumn :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> m ()

-- | Sets the <a>Adjustment</a> for the current vertical aspect.
treeViewSetVadjustment :: (HasCallStack, MonadIO m, IsTreeView a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Undoes the effect of <a>treeViewEnableModelDragDest</a>. Calling this
--   method sets <a>TreeView:reorderable</a> to <a>False</a>.
treeViewUnsetRowsDragDest :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m ()

-- | Undoes the effect of <a>treeViewEnableModelDragSource</a>. Calling
--   this method sets <a>TreeView:reorderable</a> to <a>False</a>.
treeViewUnsetRowsDragSource :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m ()

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeSelection #changed callback
--   </pre>
onTreeSelectionChanged :: (IsTreeSelection a, MonadIO m) => a -> ((?self :: a) => TreeSelectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeSelection #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeSelectionChanged :: (IsTreeSelection a, MonadIO m) => a -> ((?self :: a) => TreeSelectionChangedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>mode</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeSelection #mode
--   </pre>
getTreeSelectionMode :: (MonadIO m, IsTreeSelection o) => o -> m SelectionMode

-- | Set the value of the “<tt>mode</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeSelection [ #mode <a>:=</a> value ]
--   </pre>
setTreeSelectionMode :: (MonadIO m, IsTreeSelection o) => o -> SelectionMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>mode</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeSelectionMode :: (IsTreeSelection o, MonadIO m) => SelectionMode -> m (GValueConstruct o)

-- | Returns the number of rows that have been selected in
--   <i><tt>tree</tt></i>.
--   
--   <i>Since: 2.2</i>
treeSelectionCountSelectedRows :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m Int32

-- | Gets the selection mode for <i><tt>selection</tt></i>. See
--   <a>treeSelectionSetMode</a>.
treeSelectionGetMode :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m SelectionMode

-- | Sets <i><tt>iter</tt></i> to the currently selected node, if
--   <i><tt>selection</tt></i> is set to <a>SelectionModeSingle</a> or
--   <a>SelectionModeBrowse</a>.
--   
--   The <i><tt>iter</tt></i> argument may be <a>Nothing</a> if you just
--   want to test if <i><tt>selection</tt></i> has any selected nodes.
--   
--   The <i><tt>model</tt></i> argument is filled with the current model as
--   a convenience.
--   
--   This function will not work with <a>SelectionModeMultiple</a>. See
--   <a>treeSelectionGetSelectedRows</a> instead.
treeSelectionGetSelected :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m (Bool, TreeModel, TreeIter)

-- | Creates a list of path of all selected rows.
--   
--   Additionally, if you are planning on modifying the model after calling
--   this function, you may want to convert the returned list into a list
--   of <tt><i>GtkTreeRowReferences</i></tt>.
--   
--   To do this, you can use <a>treeRowReferenceNew</a>.
--   
--   To free the return value, use:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
--   </pre>
--   
--   <i>Since: 2.2</i>
treeSelectionGetSelectedRows :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m ([TreePath], TreeModel)

-- | Returns the tree view associated with <i><tt>selection</tt></i>.
treeSelectionGetTreeView :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m TreeView

-- | Returns <a>True</a> if the row at <i><tt>iter</tt></i> is currently
--   selected.
treeSelectionIterIsSelected :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreeIter -> m Bool

-- | Returns <a>True</a> if the row pointed to by <i><tt>path</tt></i> is
--   currently selected. If <i><tt>path</tt></i> does not point to a valid
--   location, <a>False</a> is returned
treeSelectionPathIsSelected :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreePath -> m Bool

-- | Selects all the nodes. <i><tt>selection</tt></i> must be set to
--   <tt><i>GTK_SELECTION_MULTIPLE</i></tt> mode.
treeSelectionSelectAll :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m ()

-- | Selects the specified iterator.
treeSelectionSelectIter :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreeIter -> m ()

-- | Select the row at <i><tt>path</tt></i>.
treeSelectionSelectPath :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreePath -> m ()

-- | Selects a range of nodes, determined by <i><tt>startPath</tt></i> and
--   <i><tt>endPath</tt></i> inclusive. <i><tt>selection</tt></i> must be
--   set to <tt><i>GTK_SELECTION_MULTIPLE</i></tt> mode.
treeSelectionSelectRange :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreePath -> TreePath -> m ()

-- | Sets the selection mode of the <i><tt>selection</tt></i>. If the
--   previous type was <tt><i>GTK_SELECTION_MULTIPLE</i></tt>, then the
--   anchor is kept selected, if it was previously selected.
treeSelectionSetMode :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> SelectionMode -> m ()

-- | Unselects all the nodes.
treeSelectionUnselectAll :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m ()

-- | Unselects the specified iterator.
treeSelectionUnselectIter :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreeIter -> m ()

-- | Unselects the row at <i><tt>path</tt></i>.
treeSelectionUnselectPath :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreePath -> m ()

-- | Unselects a range of nodes, determined by <i><tt>startPath</tt></i>
--   and <i><tt>endPath</tt></i> inclusive.
--   
--   <i>Since: 2.2</i>
treeSelectionUnselectRange :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreePath -> TreePath -> m ()

-- | Connect a signal handler for the <a>actionActivated</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> entryCompletion #actionActivated callback
--   </pre>
onEntryCompletionActionActivated :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionActionActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>actionActivated</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> entryCompletion #actionActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryCompletionActionActivated :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionActionActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cursorOnMatch</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> entryCompletion #cursorOnMatch callback
--   </pre>
onEntryCompletionCursorOnMatch :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionCursorOnMatchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cursorOnMatch</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> entryCompletion #cursorOnMatch callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryCompletionCursorOnMatch :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionCursorOnMatchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertPrefix</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entryCompletion #insertPrefix callback
--   </pre>
onEntryCompletionInsertPrefix :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionInsertPrefixCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertPrefix</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entryCompletion #insertPrefix callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryCompletionInsertPrefix :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionInsertPrefixCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>matchSelected</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> entryCompletion #matchSelected callback
--   </pre>
onEntryCompletionMatchSelected :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionMatchSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>matchSelected</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> entryCompletion #matchSelected callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryCompletionMatchSelected :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionMatchSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>noMatches</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entryCompletion #noMatches callback
--   </pre>
onEntryCompletionNoMatches :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionNoMatchesCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>noMatches</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entryCompletion #noMatches callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryCompletionNoMatches :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionNoMatchesCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>cell-area</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #cellArea
--   </pre>
getEntryCompletionCellArea :: (MonadIO m, IsEntryCompletion o) => o -> m (Maybe CellArea)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-area</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryCompletionCellArea :: (IsEntryCompletion o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>inline-completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #inlineCompletion
--   </pre>
getEntryCompletionInlineCompletion :: (MonadIO m, IsEntryCompletion o) => o -> m Bool

-- | Set the value of the “<tt>inline-completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryCompletion [ #inlineCompletion <a>:=</a> value ]
--   </pre>
setEntryCompletionInlineCompletion :: (MonadIO m, IsEntryCompletion o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inline-completion</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryCompletionInlineCompletion :: (IsEntryCompletion o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>inline-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #inlineSelection
--   </pre>
getEntryCompletionInlineSelection :: (MonadIO m, IsEntryCompletion o) => o -> m Bool

-- | Set the value of the “<tt>inline-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryCompletion [ #inlineSelection <a>:=</a> value ]
--   </pre>
setEntryCompletionInlineSelection :: (MonadIO m, IsEntryCompletion o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inline-selection</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryCompletionInlineSelection :: (IsEntryCompletion o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>minimum-key-length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #minimumKeyLength
--   </pre>
getEntryCompletionMinimumKeyLength :: (MonadIO m, IsEntryCompletion o) => o -> m Int32

-- | Set the value of the “<tt>minimum-key-length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryCompletion [ #minimumKeyLength <a>:=</a> value ]
--   </pre>
setEntryCompletionMinimumKeyLength :: (MonadIO m, IsEntryCompletion o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>minimum-key-length</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryCompletionMinimumKeyLength :: (IsEntryCompletion o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #model
--   </pre>
getEntryCompletionModel :: (MonadIO m, IsEntryCompletion o) => o -> m (Maybe TreeModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryCompletion [ #model <a>:=</a> value ]
--   </pre>
setEntryCompletionModel :: (MonadIO m, IsEntryCompletion o, IsTreeModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEntryCompletionModel :: (IsEntryCompletion o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearEntryCompletionModel :: (MonadIO m, IsEntryCompletion o) => o -> m ()

-- | Get the value of the “<tt>popup-completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #popupCompletion
--   </pre>
getEntryCompletionPopupCompletion :: (MonadIO m, IsEntryCompletion o) => o -> m Bool

-- | Set the value of the “<tt>popup-completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryCompletion [ #popupCompletion <a>:=</a> value ]
--   </pre>
setEntryCompletionPopupCompletion :: (MonadIO m, IsEntryCompletion o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>popup-completion</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryCompletionPopupCompletion :: (IsEntryCompletion o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>popup-set-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #popupSetWidth
--   </pre>
getEntryCompletionPopupSetWidth :: (MonadIO m, IsEntryCompletion o) => o -> m Bool

-- | Set the value of the “<tt>popup-set-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryCompletion [ #popupSetWidth <a>:=</a> value ]
--   </pre>
setEntryCompletionPopupSetWidth :: (MonadIO m, IsEntryCompletion o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>popup-set-width</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryCompletionPopupSetWidth :: (IsEntryCompletion o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>popup-single-match</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #popupSingleMatch
--   </pre>
getEntryCompletionPopupSingleMatch :: (MonadIO m, IsEntryCompletion o) => o -> m Bool

-- | Set the value of the “<tt>popup-single-match</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryCompletion [ #popupSingleMatch <a>:=</a> value ]
--   </pre>
setEntryCompletionPopupSingleMatch :: (MonadIO m, IsEntryCompletion o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>popup-single-match</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryCompletionPopupSingleMatch :: (IsEntryCompletion o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>text-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #textColumn
--   </pre>
getEntryCompletionTextColumn :: (MonadIO m, IsEntryCompletion o) => o -> m Int32

-- | Set the value of the “<tt>text-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryCompletion [ #textColumn <a>:=</a> value ]
--   </pre>
setEntryCompletionTextColumn :: (MonadIO m, IsEntryCompletion o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-column</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructEntryCompletionTextColumn :: (IsEntryCompletion o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new <a>EntryCompletion</a> object.
--   
--   <i>Since: 2.4</i>
entryCompletionNew :: (HasCallStack, MonadIO m) => m EntryCompletion

-- | Creates a new <a>EntryCompletion</a> object using the specified
--   <i><tt>area</tt></i> to layout cells in the underlying
--   <a>TreeViewColumn</a> for the drop-down menu.
--   
--   <i>Since: 3.0</i>
entryCompletionNewWithArea :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m EntryCompletion

-- | Requests a completion operation, or in other words a refiltering of
--   the current list with completions, using the current key. The
--   completion list view will be updated accordingly.
--   
--   <i>Since: 2.4</i>
entryCompletionComplete :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m ()

-- | Computes the common prefix that is shared by all rows in
--   <i><tt>completion</tt></i> that start with <i><tt>key</tt></i>. If no
--   row matches <i><tt>key</tt></i>, <a>Nothing</a> will be returned. Note
--   that a text column must have been set for this function to work, see
--   <a>entryCompletionSetTextColumn</a> for details.
--   
--   <i>Since: 3.4</i>
entryCompletionComputePrefix :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Text -> m (Maybe Text)

-- | Deletes the action at <i><tt>index_</tt></i> from
--   <i><tt>completion</tt></i>’s action list.
--   
--   Note that <i><tt>index_</tt></i> is a relative position and the
--   position of an action may have changed since it was inserted.
--   
--   <i>Since: 2.4</i>
entryCompletionDeleteAction :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Int32 -> m ()

-- | Get the original text entered by the user that triggered the
--   completion or <a>Nothing</a> if there’s no completion ongoing.
--   
--   <i>Since: 2.12</i>
entryCompletionGetCompletionPrefix :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Text

-- | Gets the entry <i><tt>completion</tt></i> has been attached to.
--   
--   <i>Since: 2.4</i>
entryCompletionGetEntry :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Widget

-- | Returns whether the common prefix of the possible completions should
--   be automatically inserted in the entry.
--   
--   <i>Since: 2.6</i>
entryCompletionGetInlineCompletion :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Bool

-- | Returns <a>True</a> if inline-selection mode is turned on.
--   
--   <i>Since: 2.12</i>
entryCompletionGetInlineSelection :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Bool

-- | Returns the minimum key length as set for <i><tt>completion</tt></i>.
--   
--   <i>Since: 2.4</i>
entryCompletionGetMinimumKeyLength :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Int32

-- | Returns the model the <a>EntryCompletion</a> is using as data source.
--   Returns <a>Nothing</a> if the model is unset.
--   
--   <i>Since: 2.4</i>
entryCompletionGetModel :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m (Maybe TreeModel)

-- | Returns whether the completions should be presented in a popup window.
--   
--   <i>Since: 2.6</i>
entryCompletionGetPopupCompletion :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Bool

-- | Returns whether the completion popup window will be resized to the
--   width of the entry.
--   
--   <i>Since: 2.8</i>
entryCompletionGetPopupSetWidth :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Bool

-- | Returns whether the completion popup window will appear even if there
--   is only a single match.
--   
--   <i>Since: 2.8</i>
entryCompletionGetPopupSingleMatch :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Bool

-- | Returns the column in the model of <i><tt>completion</tt></i> to get
--   strings from.
--   
--   <i>Since: 2.6</i>
entryCompletionGetTextColumn :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Int32

-- | Inserts an action in <i><tt>completion</tt></i>’s action item list at
--   position <i><tt>index_</tt></i> with markup <i><tt>markup</tt></i>.
--   
--   <i>Since: 2.4</i>
entryCompletionInsertActionMarkup :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Int32 -> Text -> m ()

-- | Inserts an action in <i><tt>completion</tt></i>’s action item list at
--   position <i><tt>index_</tt></i> with text <i><tt>text</tt></i>. If you
--   want the action item to have markup, use
--   <a>entryCompletionInsertActionMarkup</a>.
--   
--   Note that <i><tt>index_</tt></i> is a relative position in the list of
--   actions and the position of an action can change when deleting a
--   different action.
--   
--   <i>Since: 2.4</i>
entryCompletionInsertActionText :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Int32 -> Text -> m ()

-- | Requests a prefix insertion.
--   
--   <i>Since: 2.6</i>
entryCompletionInsertPrefix :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m ()

-- | Sets whether the common prefix of the possible completions should be
--   automatically inserted in the entry.
--   
--   <i>Since: 2.6</i>
entryCompletionSetInlineCompletion :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Bool -> m ()

-- | Sets whether it is possible to cycle through the possible completions
--   inside the entry.
--   
--   <i>Since: 2.12</i>
entryCompletionSetInlineSelection :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Bool -> m ()

-- | Requires the length of the search key for <i><tt>completion</tt></i>
--   to be at least <i><tt>length</tt></i>. This is useful for long lists,
--   where completing using a small key takes a lot of time and will come
--   up with meaningless results anyway (ie, a too large dataset).
--   
--   <i>Since: 2.4</i>
entryCompletionSetMinimumKeyLength :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Int32 -> m ()

-- | Sets the model for a <a>EntryCompletion</a>. If
--   <i><tt>completion</tt></i> already has a model set, it will remove it
--   before setting the new model. If model is <a>Nothing</a>, then it will
--   unset the model.
--   
--   <i>Since: 2.4</i>
entryCompletionSetModel :: (HasCallStack, MonadIO m, IsEntryCompletion a, IsTreeModel b) => a -> Maybe b -> m ()

-- | Sets whether the completions should be presented in a popup window.
--   
--   <i>Since: 2.6</i>
entryCompletionSetPopupCompletion :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Bool -> m ()

-- | Sets whether the completion popup window will be resized to be the
--   same width as the entry.
--   
--   <i>Since: 2.8</i>
entryCompletionSetPopupSetWidth :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Bool -> m ()

-- | Sets whether the completion popup window will appear even if there is
--   only a single match. You may want to set this to <a>False</a> if you
--   are using [inline completion][GtkEntryCompletion--inline-completion].
--   
--   <i>Since: 2.8</i>
entryCompletionSetPopupSingleMatch :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Bool -> m ()

-- | Convenience function for setting up the most used case of this code: a
--   completion list with just strings. This function will set up
--   <i><tt>completion</tt></i> to have a list displaying all (and just)
--   strings in the completion list, and to get those strings from
--   <i><tt>column</tt></i> in the model of <i><tt>completion</tt></i>.
--   
--   This functions creates and adds a <a>CellRendererText</a> for the
--   selected column. If you need to set the text column, but don't want
--   the cell renderer, use <tt><i>g_object_set()</i></tt> to set the
--   <a>EntryCompletion:textColumn</a> property directly.
--   
--   <i>Since: 2.4</i>
entryCompletionSetTextColumn :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Int32 -> m ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entry #activate callback
--   </pre>
onEntryActivate :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entry #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryActivate :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>backspace</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entry #backspace callback
--   </pre>
onEntryBackspace :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryBackspaceCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>backspace</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entry #backspace callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryBackspace :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryBackspaceCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>copyClipboard</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> entry #copyClipboard callback
--   </pre>
onEntryCopyClipboard :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryCopyClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>copyClipboard</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> entry #copyClipboard callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryCopyClipboard :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryCopyClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cutClipboard</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entry #cutClipboard callback
--   </pre>
onEntryCutClipboard :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryCutClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cutClipboard</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entry #cutClipboard callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryCutClipboard :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryCutClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteFromCursor</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> entry #deleteFromCursor callback
--   </pre>
onEntryDeleteFromCursor :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryDeleteFromCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteFromCursor</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> entry #deleteFromCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryDeleteFromCursor :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryDeleteFromCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>iconPress</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entry #iconPress callback
--   </pre>
onEntryIconPress :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryIconPressCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>iconPress</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entry #iconPress callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryIconPress :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryIconPressCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>iconRelease</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entry #iconRelease callback
--   </pre>
onEntryIconRelease :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryIconReleaseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>iconRelease</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entry #iconRelease callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryIconRelease :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryIconReleaseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertAtCursor</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> entry #insertAtCursor callback
--   </pre>
onEntryInsertAtCursor :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryInsertAtCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertAtCursor</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> entry #insertAtCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryInsertAtCursor :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryInsertAtCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertEmoji</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entry #insertEmoji callback
--   </pre>
onEntryInsertEmoji :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryInsertEmojiCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertEmoji</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entry #insertEmoji callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryInsertEmoji :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryInsertEmojiCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entry #moveCursor callback
--   </pre>
onEntryMoveCursor :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entry #moveCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryMoveCursor :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pasteClipboard</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> entry #pasteClipboard callback
--   </pre>
onEntryPasteClipboard :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryPasteClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pasteClipboard</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> entry #pasteClipboard callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryPasteClipboard :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryPasteClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>populatePopup</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> entry #populatePopup callback
--   </pre>
onEntryPopulatePopup :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryPopulatePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>populatePopup</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> entry #populatePopup callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryPopulatePopup :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryPopulatePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preeditChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> entry #preeditChanged callback
--   </pre>
onEntryPreeditChanged :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryPreeditChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preeditChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> entry #preeditChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryPreeditChanged :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryPreeditChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleOverwrite</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> entry #toggleOverwrite callback
--   </pre>
onEntryToggleOverwrite :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryToggleOverwriteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleOverwrite</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> entry #toggleOverwrite callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryToggleOverwrite :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryToggleOverwriteCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>activates-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #activatesDefault
--   </pre>
getEntryActivatesDefault :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>activates-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #activatesDefault <a>:=</a> value ]
--   </pre>
setEntryActivatesDefault :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activates-default</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryActivatesDefault :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #attributes
--   </pre>
getEntryAttributes :: (MonadIO m, IsEntry o) => o -> m (Maybe AttrList)

-- | Set the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #attributes <a>:=</a> value ]
--   </pre>
setEntryAttributes :: (MonadIO m, IsEntry o) => o -> AttrList -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>attributes</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryAttributes :: (IsEntry o, MonadIO m) => AttrList -> m (GValueConstruct o)

-- | Get the value of the “<tt>buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #buffer
--   </pre>
getEntryBuffer :: (MonadIO m, IsEntry o) => o -> m EntryBuffer

-- | Set the value of the “<tt>buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #buffer <a>:=</a> value ]
--   </pre>
setEntryBuffer :: (MonadIO m, IsEntry o, IsEntryBuffer a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>buffer</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEntryBuffer :: (IsEntry o, MonadIO m, IsEntryBuffer a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>caps-lock-warning</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #capsLockWarning
--   </pre>
getEntryCapsLockWarning :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>caps-lock-warning</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #capsLockWarning <a>:=</a> value ]
--   </pre>
setEntryCapsLockWarning :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>caps-lock-warning</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryCapsLockWarning :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #completion
--   </pre>
getEntryCompletion :: (MonadIO m, IsEntry o) => o -> m EntryCompletion

-- | Set the value of the “<tt>completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #completion <a>:=</a> value ]
--   </pre>
setEntryCompletion :: (MonadIO m, IsEntry o, IsEntryCompletion a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>completion</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryCompletion :: (IsEntry o, MonadIO m, IsEntryCompletion a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>completion</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #completion
--   </pre>
clearEntryCompletion :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “<tt>cursor-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #cursorPosition
--   </pre>
getEntryCursorPosition :: (MonadIO m, IsEntry o) => o -> m Int32

-- | Get the value of the “<tt>editable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #editable
--   </pre>
getEntryEditable :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>editable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #editable <a>:=</a> value ]
--   </pre>
setEntryEditable :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>editable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryEditable :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>enable-emoji-completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #enableEmojiCompletion
--   </pre>
getEntryEnableEmojiCompletion :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>enable-emoji-completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #enableEmojiCompletion <a>:=</a> value ]
--   </pre>
setEntryEnableEmojiCompletion :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-emoji-completion</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryEnableEmojiCompletion :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-frame</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #hasFrame
--   </pre>
getEntryHasFrame :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>has-frame</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #hasFrame <a>:=</a> value ]
--   </pre>
setEntryHasFrame :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-frame</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryHasFrame :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>im-module</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #imModule
--   </pre>
getEntryImModule :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>im-module</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #imModule <a>:=</a> value ]
--   </pre>
setEntryImModule :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>im-module</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryImModule :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>im-module</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #imModule
--   </pre>
clearEntryImModule :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “<tt>inner-border</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #innerBorder
--   </pre>
getEntryInnerBorder :: (MonadIO m, IsEntry o) => o -> m (Maybe Border)

-- | Set the value of the “<tt>inner-border</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #innerBorder <a>:=</a> value ]
--   </pre>
setEntryInnerBorder :: (MonadIO m, IsEntry o) => o -> Border -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inner-border</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructEntryInnerBorder :: (IsEntry o, MonadIO m) => Border -> m (GValueConstruct o)

-- | Set the value of the “<tt>inner-border</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #innerBorder
--   </pre>
clearEntryInnerBorder :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “<tt>input-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #inputHints
--   </pre>
getEntryInputHints :: (MonadIO m, IsEntry o) => o -> m [InputHints]

-- | Set the value of the “<tt>input-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #inputHints <a>:=</a> value ]
--   </pre>
setEntryInputHints :: (MonadIO m, IsEntry o) => o -> [InputHints] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-hints</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructEntryInputHints :: (IsEntry o, MonadIO m) => [InputHints] -> m (GValueConstruct o)

-- | Get the value of the “<tt>input-purpose</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #inputPurpose
--   </pre>
getEntryInputPurpose :: (MonadIO m, IsEntry o) => o -> m InputPurpose

-- | Set the value of the “<tt>input-purpose</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #inputPurpose <a>:=</a> value ]
--   </pre>
setEntryInputPurpose :: (MonadIO m, IsEntry o) => o -> InputPurpose -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-purpose</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructEntryInputPurpose :: (IsEntry o, MonadIO m) => InputPurpose -> m (GValueConstruct o)

-- | Get the value of the “<tt>invisible-char</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #invisibleChar
--   </pre>
getEntryInvisibleChar :: (MonadIO m, IsEntry o) => o -> m Word32

-- | Set the value of the “<tt>invisible-char</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #invisibleChar <a>:=</a> value ]
--   </pre>
setEntryInvisibleChar :: (MonadIO m, IsEntry o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>invisible-char</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryInvisibleChar :: (IsEntry o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>invisible-char-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #invisibleCharSet
--   </pre>
getEntryInvisibleCharSet :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>invisible-char-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #invisibleCharSet <a>:=</a> value ]
--   </pre>
setEntryInvisibleCharSet :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>invisible-char-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryInvisibleCharSet :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #maxLength
--   </pre>
getEntryMaxLength :: (MonadIO m, IsEntry o) => o -> m Int32

-- | Set the value of the “<tt>max-length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #maxLength <a>:=</a> value ]
--   </pre>
setEntryMaxLength :: (MonadIO m, IsEntry o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-length</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryMaxLength :: (IsEntry o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #maxWidthChars
--   </pre>
getEntryMaxWidthChars :: (MonadIO m, IsEntry o) => o -> m Int32

-- | Set the value of the “<tt>max-width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #maxWidthChars <a>:=</a> value ]
--   </pre>
setEntryMaxWidthChars :: (MonadIO m, IsEntry o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-width-chars</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryMaxWidthChars :: (IsEntry o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>overwrite-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #overwriteMode
--   </pre>
getEntryOverwriteMode :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>overwrite-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #overwriteMode <a>:=</a> value ]
--   </pre>
setEntryOverwriteMode :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>overwrite-mode</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryOverwriteMode :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>placeholder-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #placeholderText
--   </pre>
getEntryPlaceholderText :: (MonadIO m, IsEntry o) => o -> m Text

-- | Set the value of the “<tt>placeholder-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #placeholderText <a>:=</a> value ]
--   </pre>
setEntryPlaceholderText :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>placeholder-text</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryPlaceholderText :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>placeholder-text</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #placeholderText
--   </pre>
clearEntryPlaceholderText :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “<tt>populate-all</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #populateAll
--   </pre>
getEntryPopulateAll :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>populate-all</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #populateAll <a>:=</a> value ]
--   </pre>
setEntryPopulateAll :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>populate-all</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructEntryPopulateAll :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>primary-icon-activatable</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconActivatable
--   </pre>
getEntryPrimaryIconActivatable :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>primary-icon-activatable</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #primaryIconActivatable <a>:=</a> value ]
--   </pre>
setEntryPrimaryIconActivatable :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>primary-icon-activatable</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryPrimaryIconActivatable :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>primary-icon-gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconGicon
--   </pre>
getEntryPrimaryIconGicon :: (MonadIO m, IsEntry o) => o -> m (Maybe Icon)

-- | Set the value of the “<tt>primary-icon-gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #primaryIconGicon <a>:=</a> value ]
--   </pre>
setEntryPrimaryIconGicon :: (MonadIO m, IsEntry o, IsIcon a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>primary-icon-gicon</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryPrimaryIconGicon :: (IsEntry o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>primary-icon-gicon</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #primaryIconGicon
--   </pre>
clearEntryPrimaryIconGicon :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “<tt>primary-icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconName
--   </pre>
getEntryPrimaryIconName :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>primary-icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #primaryIconName <a>:=</a> value ]
--   </pre>
setEntryPrimaryIconName :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>primary-icon-name</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryPrimaryIconName :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>primary-icon-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #primaryIconName
--   </pre>
clearEntryPrimaryIconName :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “<tt>primary-icon-pixbuf</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconPixbuf
--   </pre>
getEntryPrimaryIconPixbuf :: (MonadIO m, IsEntry o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “<tt>primary-icon-pixbuf</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #primaryIconPixbuf <a>:=</a> value ]
--   </pre>
setEntryPrimaryIconPixbuf :: (MonadIO m, IsEntry o, IsPixbuf a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>primary-icon-pixbuf</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryPrimaryIconPixbuf :: (IsEntry o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>primary-icon-pixbuf</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #primaryIconPixbuf
--   </pre>
clearEntryPrimaryIconPixbuf :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “<tt>primary-icon-sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconSensitive
--   </pre>
getEntryPrimaryIconSensitive :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>primary-icon-sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #primaryIconSensitive <a>:=</a> value ]
--   </pre>
setEntryPrimaryIconSensitive :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>primary-icon-sensitive</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryPrimaryIconSensitive :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>primary-icon-stock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconStock
--   </pre>
getEntryPrimaryIconStock :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>primary-icon-stock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #primaryIconStock <a>:=</a> value ]
--   </pre>
setEntryPrimaryIconStock :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>primary-icon-stock</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryPrimaryIconStock :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>primary-icon-stock</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #primaryIconStock
--   </pre>
clearEntryPrimaryIconStock :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “<tt>primary-icon-storage-type</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconStorageType
--   </pre>
getEntryPrimaryIconStorageType :: (MonadIO m, IsEntry o) => o -> m ImageType

-- | Get the value of the “<tt>primary-icon-tooltip-markup</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconTooltipMarkup
--   </pre>
getEntryPrimaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>primary-icon-tooltip-markup</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #primaryIconTooltipMarkup <a>:=</a> value ]
--   </pre>
setEntryPrimaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>primary-icon-tooltip-markup</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryPrimaryIconTooltipMarkup :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>primary-icon-tooltip-markup</tt>” property
--   to <a>Nothing</a>. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>clear</a> #primaryIconTooltipMarkup
--   </pre>
clearEntryPrimaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “<tt>primary-icon-tooltip-text</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconTooltipText
--   </pre>
getEntryPrimaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>primary-icon-tooltip-text</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #primaryIconTooltipText <a>:=</a> value ]
--   </pre>
setEntryPrimaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>primary-icon-tooltip-text</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryPrimaryIconTooltipText :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>primary-icon-tooltip-text</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #primaryIconTooltipText
--   </pre>
clearEntryPrimaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “<tt>progress-fraction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #progressFraction
--   </pre>
getEntryProgressFraction :: (MonadIO m, IsEntry o) => o -> m Double

-- | Set the value of the “<tt>progress-fraction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #progressFraction <a>:=</a> value ]
--   </pre>
setEntryProgressFraction :: (MonadIO m, IsEntry o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>progress-fraction</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryProgressFraction :: (IsEntry o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>progress-pulse-step</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #progressPulseStep
--   </pre>
getEntryProgressPulseStep :: (MonadIO m, IsEntry o) => o -> m Double

-- | Set the value of the “<tt>progress-pulse-step</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #progressPulseStep <a>:=</a> value ]
--   </pre>
setEntryProgressPulseStep :: (MonadIO m, IsEntry o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>progress-pulse-step</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryProgressPulseStep :: (IsEntry o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>scroll-offset</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #scrollOffset
--   </pre>
getEntryScrollOffset :: (MonadIO m, IsEntry o) => o -> m Int32

-- | Get the value of the “<tt>secondary-icon-activatable</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconActivatable
--   </pre>
getEntrySecondaryIconActivatable :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>secondary-icon-activatable</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #secondaryIconActivatable <a>:=</a> value ]
--   </pre>
setEntrySecondaryIconActivatable :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-icon-activatable</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntrySecondaryIconActivatable :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>secondary-icon-gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconGicon
--   </pre>
getEntrySecondaryIconGicon :: (MonadIO m, IsEntry o) => o -> m (Maybe Icon)

-- | Set the value of the “<tt>secondary-icon-gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #secondaryIconGicon <a>:=</a> value ]
--   </pre>
setEntrySecondaryIconGicon :: (MonadIO m, IsEntry o, IsIcon a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-icon-gicon</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntrySecondaryIconGicon :: (IsEntry o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>secondary-icon-gicon</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #secondaryIconGicon
--   </pre>
clearEntrySecondaryIconGicon :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “<tt>secondary-icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconName
--   </pre>
getEntrySecondaryIconName :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>secondary-icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #secondaryIconName <a>:=</a> value ]
--   </pre>
setEntrySecondaryIconName :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-icon-name</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntrySecondaryIconName :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>secondary-icon-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #secondaryIconName
--   </pre>
clearEntrySecondaryIconName :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “<tt>secondary-icon-pixbuf</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconPixbuf
--   </pre>
getEntrySecondaryIconPixbuf :: (MonadIO m, IsEntry o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “<tt>secondary-icon-pixbuf</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #secondaryIconPixbuf <a>:=</a> value ]
--   </pre>
setEntrySecondaryIconPixbuf :: (MonadIO m, IsEntry o, IsPixbuf a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-icon-pixbuf</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntrySecondaryIconPixbuf :: (IsEntry o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>secondary-icon-pixbuf</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #secondaryIconPixbuf
--   </pre>
clearEntrySecondaryIconPixbuf :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “<tt>secondary-icon-sensitive</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconSensitive
--   </pre>
getEntrySecondaryIconSensitive :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>secondary-icon-sensitive</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #secondaryIconSensitive <a>:=</a> value ]
--   </pre>
setEntrySecondaryIconSensitive :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-icon-sensitive</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntrySecondaryIconSensitive :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>secondary-icon-stock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconStock
--   </pre>
getEntrySecondaryIconStock :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>secondary-icon-stock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #secondaryIconStock <a>:=</a> value ]
--   </pre>
setEntrySecondaryIconStock :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-icon-stock</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntrySecondaryIconStock :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>secondary-icon-stock</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #secondaryIconStock
--   </pre>
clearEntrySecondaryIconStock :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “<tt>secondary-icon-storage-type</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconStorageType
--   </pre>
getEntrySecondaryIconStorageType :: (MonadIO m, IsEntry o) => o -> m ImageType

-- | Get the value of the “<tt>secondary-icon-tooltip-markup</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconTooltipMarkup
--   </pre>
getEntrySecondaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>secondary-icon-tooltip-markup</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #secondaryIconTooltipMarkup <a>:=</a> value ]
--   </pre>
setEntrySecondaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-icon-tooltip-markup</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructEntrySecondaryIconTooltipMarkup :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>secondary-icon-tooltip-markup</tt>” property
--   to <a>Nothing</a>. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>clear</a> #secondaryIconTooltipMarkup
--   </pre>
clearEntrySecondaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “<tt>secondary-icon-tooltip-text</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconTooltipText
--   </pre>
getEntrySecondaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>secondary-icon-tooltip-text</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #secondaryIconTooltipText <a>:=</a> value ]
--   </pre>
setEntrySecondaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-icon-tooltip-text</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntrySecondaryIconTooltipText :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>secondary-icon-tooltip-text</tt>” property
--   to <a>Nothing</a>. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>clear</a> #secondaryIconTooltipText
--   </pre>
clearEntrySecondaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m ()

-- | Get the value of the “<tt>selection-bound</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #selectionBound
--   </pre>
getEntrySelectionBound :: (MonadIO m, IsEntry o) => o -> m Int32

-- | Get the value of the “<tt>shadow-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #shadowType
--   </pre>
getEntryShadowType :: (MonadIO m, IsEntry o) => o -> m ShadowType

-- | Set the value of the “<tt>shadow-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #shadowType <a>:=</a> value ]
--   </pre>
setEntryShadowType :: (MonadIO m, IsEntry o) => o -> ShadowType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>shadow-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructEntryShadowType :: (IsEntry o, MonadIO m) => ShadowType -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-emoji-icon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #showEmojiIcon
--   </pre>
getEntryShowEmojiIcon :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>show-emoji-icon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #showEmojiIcon <a>:=</a> value ]
--   </pre>
setEntryShowEmojiIcon :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-emoji-icon</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryShowEmojiIcon :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>tabs</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #tabs
--   </pre>
getEntryTabs :: (MonadIO m, IsEntry o) => o -> m (Maybe TabArray)

-- | Set the value of the “<tt>tabs</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #tabs <a>:=</a> value ]
--   </pre>
setEntryTabs :: (MonadIO m, IsEntry o) => o -> TabArray -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tabs</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEntryTabs :: (IsEntry o, MonadIO m) => TabArray -> m (GValueConstruct o)

-- | Get the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #text
--   </pre>
getEntryText :: (MonadIO m, IsEntry o) => o -> m Text

-- | Set the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #text <a>:=</a> value ]
--   </pre>
setEntryText :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEntryText :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>text-length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #textLength
--   </pre>
getEntryTextLength :: (MonadIO m, IsEntry o) => o -> m Word32

-- | Get the value of the “<tt>truncate-multiline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #truncateMultiline
--   </pre>
getEntryTruncateMultiline :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>truncate-multiline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #truncateMultiline <a>:=</a> value ]
--   </pre>
setEntryTruncateMultiline :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>truncate-multiline</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryTruncateMultiline :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visibility</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #visibility
--   </pre>
getEntryVisibility :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>visibility</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #visibility <a>:=</a> value ]
--   </pre>
setEntryVisibility :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visibility</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryVisibility :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #widthChars
--   </pre>
getEntryWidthChars :: (MonadIO m, IsEntry o) => o -> m Int32

-- | Set the value of the “<tt>width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #widthChars <a>:=</a> value ]
--   </pre>
setEntryWidthChars :: (MonadIO m, IsEntry o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>width-chars</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructEntryWidthChars :: (IsEntry o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #xalign
--   </pre>
getEntryXalign :: (MonadIO m, IsEntry o) => o -> m Float

-- | Set the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #xalign <a>:=</a> value ]
--   </pre>
setEntryXalign :: (MonadIO m, IsEntry o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>xalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEntryXalign :: (IsEntry o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Creates a new entry.
entryNew :: (HasCallStack, MonadIO m) => m Entry

-- | Creates a new entry with the specified text buffer.
--   
--   <i>Since: 2.18</i>
entryNewWithBuffer :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m Entry

-- | Retrieves the value set by <a>entrySetActivatesDefault</a>.
entryGetActivatesDefault :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool

-- | Gets the value set by <a>entrySetAlignment</a>.
--   
--   <i>Since: 2.4</i>
entryGetAlignment :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Float

-- | Gets the attribute list that was set on the entry using
--   <a>entrySetAttributes</a>, if any.
--   
--   <i>Since: 3.6</i>
entryGetAttributes :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe AttrList)

-- | Get the <a>EntryBuffer</a> object which holds the text for this
--   widget.
--   
--   <i>Since: 2.18</i>
entryGetBuffer :: (HasCallStack, MonadIO m, IsEntry a) => a -> m EntryBuffer

-- | Returns the auxiliary completion object currently in use by
--   <i><tt>entry</tt></i>.
--   
--   <i>Since: 2.4</i>
entryGetCompletion :: (HasCallStack, MonadIO m, IsEntry a) => a -> m EntryCompletion

-- | Returns the index of the icon which is the source of the current DND
--   operation, or -1.
--   
--   This function is meant to be used in a <a>Widget::dragDataGet</a>
--   callback.
--   
--   <i>Since: 2.16</i>
entryGetCurrentIconDragSource :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Int32

-- | Retrieves the horizontal cursor adjustment for the entry. See
--   <a>entrySetCursorHadjustment</a>.
--   
--   <i>Since: 2.12</i>
entryGetCursorHadjustment :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe Adjustment)

-- | Gets the value set by <a>entrySetHasFrame</a>.
entryGetHasFrame :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool

-- | Returns whether the icon is activatable.
--   
--   <i>Since: 2.16</i>
entryGetIconActivatable :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m Bool

-- | Gets the area where entry’s icon at <i><tt>iconPos</tt></i> is drawn.
--   This function is useful when drawing something to the entry in a draw
--   callback.
--   
--   If the entry is not realized or has no icon at the given position,
--   <i><tt>iconArea</tt></i> is filled with zeros. Otherwise,
--   <i><tt>iconArea</tt></i> will be filled with the icon’s allocation,
--   relative to <i><tt>entry</tt></i>’s allocation.
--   
--   See also <a>entryGetTextArea</a>
--   
--   <i>Since: 3.0</i>
entryGetIconArea :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m Rectangle

-- | Finds the icon at the given position and return its index. The
--   position’s coordinates are relative to the <i><tt>entry</tt></i>’s top
--   left corner. If <i><tt>x</tt></i>, <i><tt>y</tt></i> doesn’t lie
--   inside an icon, -1 is returned. This function is intended for use in a
--   <a>Widget::queryTooltip</a> signal handler.
--   
--   <i>Since: 2.16</i>
entryGetIconAtPos :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> Int32 -> m Int32

-- | Retrieves the <a>Icon</a> used for the icon, or <a>Nothing</a> if
--   there is no icon or if the icon was set by some other method (e.g., by
--   stock, pixbuf, or icon name).
--   
--   <i>Since: 2.16</i>
entryGetIconGicon :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Icon)

-- | Retrieves the icon name used for the icon, or <a>Nothing</a> if there
--   is no icon or if the icon was set by some other method (e.g., by
--   pixbuf, stock or gicon).
--   
--   <i>Since: 2.16</i>
entryGetIconName :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Text)

-- | Retrieves the image used for the icon.
--   
--   Unlike the other methods of setting and getting icon data, this method
--   will work regardless of whether the icon was set using a
--   <a>Pixbuf</a>, a <a>Icon</a>, a stock item, or an icon name.
--   
--   <i>Since: 2.16</i>
entryGetIconPixbuf :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Pixbuf)

-- | Returns whether the icon appears sensitive or insensitive.
--   
--   <i>Since: 2.16</i>
entryGetIconSensitive :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m Bool

-- | Retrieves the stock id used for the icon, or <a>Nothing</a> if there
--   is no icon or if the icon was set by some other method (e.g., by
--   pixbuf, icon name or gicon).
--   
--   <i>Since: 2.16</i>
entryGetIconStock :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m Text

-- | Gets the type of representation being used by the icon to store image
--   data. If the icon has no image data, the return value will be
--   <a>ImageTypeEmpty</a>.
--   
--   <i>Since: 2.16</i>
entryGetIconStorageType :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m ImageType

-- | Gets the contents of the tooltip on the icon at the specified position
--   in <i><tt>entry</tt></i>.
--   
--   <i>Since: 2.16</i>
entryGetIconTooltipMarkup :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Text)

-- | Gets the contents of the tooltip on the icon at the specified position
--   in <i><tt>entry</tt></i>.
--   
--   <i>Since: 2.16</i>
entryGetIconTooltipText :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Text)

-- | This function returns the entry’s <a>Entry:innerBorder</a> property.
--   See <a>entrySetInnerBorder</a> for more information.
--   
--   <i>Since: 2.10</i>
entryGetInnerBorder :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe Border)

-- | Gets the value of the <a>Entry:inputHints</a> property.
--   
--   <i>Since: 3.6</i>
entryGetInputHints :: (HasCallStack, MonadIO m, IsEntry a) => a -> m [InputHints]

-- | Gets the value of the <a>Entry:inputPurpose</a> property.
--   
--   <i>Since: 3.6</i>
entryGetInputPurpose :: (HasCallStack, MonadIO m, IsEntry a) => a -> m InputPurpose

-- | Retrieves the character displayed in place of the real characters for
--   entries with visibility set to false. See
--   <a>entrySetInvisibleChar</a>.
entryGetInvisibleChar :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Char

-- | Gets the <a>Layout</a> used to display the entry. The layout is useful
--   to e.g. convert text positions to pixel positions, in combination with
--   <a>entryGetLayoutOffsets</a>. The returned layout is owned by the
--   entry and must not be modified or freed by the caller.
--   
--   Keep in mind that the layout text may contain a preedit string, so
--   <a>entryLayoutIndexToTextIndex</a> and
--   <a>entryTextIndexToLayoutIndex</a> are needed to convert byte indices
--   in the layout to byte indices in the entry contents.
entryGetLayout :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Layout

-- | Obtains the position of the <a>Layout</a> used to render text in the
--   entry, in widget coordinates. Useful if you want to line up the text
--   in an entry with some other text, e.g. when using the entry to
--   implement editable cells in a sheet widget.
--   
--   Also useful to convert mouse events into coordinates inside the
--   <a>Layout</a>, e.g. to take some action if some part of the entry text
--   is clicked.
--   
--   Note that as the user scrolls around in the entry the offsets will
--   change; you’ll need to connect to the “notify<a>scrollOffset</a>”
--   signal to track this. Remember when using the <a>Layout</a> functions
--   you need to convert to and from pixels using
--   <tt><i>PANGO_PIXELS()</i></tt> or <a>SCALE</a>.
--   
--   Keep in mind that the layout text may contain a preedit string, so
--   <a>entryLayoutIndexToTextIndex</a> and
--   <a>entryTextIndexToLayoutIndex</a> are needed to convert byte indices
--   in the layout to byte indices in the entry contents.
entryGetLayoutOffsets :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Int32, Int32)

-- | Retrieves the maximum allowed length of the text in
--   <i><tt>entry</tt></i>. See <a>entrySetMaxLength</a>.
--   
--   This is equivalent to getting <i><tt>entry</tt></i>'s
--   <a>EntryBuffer</a> and calling <a>entryBufferGetMaxLength</a> on it.
entryGetMaxLength :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Int32

-- | Retrieves the desired maximum width of <i><tt>entry</tt></i>, in
--   characters. See <a>entrySetMaxWidthChars</a>.
--   
--   <i>Since: 3.12</i>
entryGetMaxWidthChars :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Int32

-- | Gets the value set by <a>entrySetOverwriteMode</a>.
--   
--   <i>Since: 2.14</i>
entryGetOverwriteMode :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool

-- | Retrieves the text that will be displayed when <i><tt>entry</tt></i>
--   is empty and unfocused
--   
--   <i>Since: 3.2</i>
entryGetPlaceholderText :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Text

-- | Returns the current fraction of the task that’s been completed. See
--   <a>entrySetProgressFraction</a>.
--   
--   <i>Since: 2.16</i>
entryGetProgressFraction :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Double

-- | Retrieves the pulse step set with <a>entrySetProgressPulseStep</a>.
--   
--   <i>Since: 2.16</i>
entryGetProgressPulseStep :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Double

-- | Gets the tabstops that were set on the entry using
--   <a>entrySetTabs</a>, if any.
--   
--   <i>Since: 3.10</i>
entryGetTabs :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe TabArray)

-- | Gets the area where the entry’s text is drawn. This function is useful
--   when drawing something to the entry in a draw callback.
--   
--   If the entry is not realized, <i><tt>textArea</tt></i> is filled with
--   zeros.
--   
--   See also <a>entryGetIconArea</a>.
--   
--   <i>Since: 3.0</i>
entryGetTextArea :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Rectangle

-- | Retrieves the current length of the text in <i><tt>entry</tt></i>.
--   
--   This is equivalent to getting <i><tt>entry</tt></i>'s
--   <a>EntryBuffer</a> and calling <a>entryBufferGetLength</a> on it.
--   
--   <i>Since: 2.14</i>
entryGetTextLength :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Word16

-- | Retrieves whether the text in <i><tt>entry</tt></i> is visible. See
--   <a>entrySetVisibility</a>.
entryGetVisibility :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool

-- | Gets the value set by <a>entrySetWidthChars</a>.
entryGetWidthChars :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Int32

-- | Causes <i><tt>entry</tt></i> to have keyboard focus.
--   
--   It behaves like <a>widgetGrabFocus</a>, except that it doesn't select
--   the contents of the entry. You only want to call this on some special
--   entries which the user usually doesn't want to replace all text in,
--   such as search-as-you-type entries.
--   
--   <i>Since: 3.16</i>
entryGrabFocusWithoutSelecting :: (HasCallStack, MonadIO m, IsEntry a) => a -> m ()

-- | Allow the <a>Entry</a> input method to internally handle key press and
--   release events. If this function returns <a>True</a>, then no further
--   processing should be done for this key event. See
--   <a>iMContextFilterKeypress</a>.
--   
--   Note that you are expected to call this function from your handler
--   when overriding key event handling. This is needed in the case when
--   you need to insert your own key handling between the input method and
--   the default key event handling of the <a>Entry</a>. See
--   <a>textViewResetImContext</a> for an example of use.
--   
--   <i>Since: 2.22</i>
entryImContextFilterKeypress :: (HasCallStack, MonadIO m, IsEntry a) => a -> EventKey -> m Bool

-- | Converts from a position in the entry’s <a>Layout</a> (returned by
--   <a>entryGetLayout</a>) to a position in the entry contents (returned
--   by <a>entryGetText</a>).
entryLayoutIndexToTextIndex :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> m Int32

-- | Indicates that some progress is made, but you don’t know how much.
--   Causes the entry’s progress indicator to enter “activity mode,” where
--   a block bounces back and forth. Each call to <a>entryProgressPulse</a>
--   causes the block to move by a little bit (the amount of movement per
--   pulse is determined by <a>entrySetProgressPulseStep</a>).
--   
--   <i>Since: 2.16</i>
entryProgressPulse :: (HasCallStack, MonadIO m, IsEntry a) => a -> m ()

-- | Reset the input method context of the entry if needed.
--   
--   This can be necessary in the case where modifying the buffer would
--   confuse on-going input method behavior.
--   
--   <i>Since: 2.22</i>
entryResetImContext :: (HasCallStack, MonadIO m, IsEntry a) => a -> m ()

-- | If <i><tt>setting</tt></i> is <a>True</a>, pressing Enter in the
--   <i><tt>entry</tt></i> will activate the default widget for the window
--   containing the entry. This usually means that the dialog box
--   containing the entry will be closed, since the default widget is
--   usually one of the dialog buttons.
--   
--   (For experts: if <i><tt>setting</tt></i> is <a>True</a>, the entry
--   calls <a>windowActivateDefault</a> on the window containing the entry,
--   in the default handler for the <a>Entry::activate</a> signal.)
entrySetActivatesDefault :: (HasCallStack, MonadIO m, IsEntry a) => a -> Bool -> m ()

-- | Sets the alignment for the contents of the entry. This controls the
--   horizontal positioning of the contents when the displayed text is
--   shorter than the width of the entry.
--   
--   <i>Since: 2.4</i>
entrySetAlignment :: (HasCallStack, MonadIO m, IsEntry a) => a -> Float -> m ()

-- | Sets a <a>AttrList</a>; the attributes in the list are applied to the
--   entry text.
--   
--   <i>Since: 3.6</i>
entrySetAttributes :: (HasCallStack, MonadIO m, IsEntry a) => a -> AttrList -> m ()

-- | Set the <a>EntryBuffer</a> object which holds the text for this
--   widget.
--   
--   <i>Since: 2.18</i>
entrySetBuffer :: (HasCallStack, MonadIO m, IsEntry a, IsEntryBuffer b) => a -> b -> m ()

-- | Sets <i><tt>completion</tt></i> to be the auxiliary completion object
--   to use with <i><tt>entry</tt></i>. All further configuration of the
--   completion mechanism is done on <i><tt>completion</tt></i> using the
--   <a>EntryCompletion</a> API. Completion is disabled if
--   <i><tt>completion</tt></i> is set to <a>Nothing</a>.
--   
--   <i>Since: 2.4</i>
entrySetCompletion :: (HasCallStack, MonadIO m, IsEntry a, IsEntryCompletion b) => a -> Maybe b -> m ()

-- | Hooks up an adjustment to the cursor position in an entry, so that
--   when the cursor is moved, the adjustment is scrolled to show that
--   position. See <a>scrolledWindowGetHadjustment</a> for a typical way of
--   obtaining the adjustment.
--   
--   The adjustment has to be in pixel units and in the same coordinate
--   system as the entry.
--   
--   <i>Since: 2.12</i>
entrySetCursorHadjustment :: (HasCallStack, MonadIO m, IsEntry a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Sets whether the entry has a beveled frame around it.
entrySetHasFrame :: (HasCallStack, MonadIO m, IsEntry a) => a -> Bool -> m ()

-- | Sets whether the icon is activatable.
--   
--   <i>Since: 2.16</i>
entrySetIconActivatable :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Bool -> m ()

-- | Sets up the icon at the given position so that GTK+ will start a drag
--   operation when the user clicks and drags the icon.
--   
--   To handle the drag operation, you need to connect to the usual
--   <a>Widget::dragDataGet</a> (or possibly <a>Widget::dragDataDelete</a>)
--   signal, and use <a>entryGetCurrentIconDragSource</a> in your signal
--   handler to find out if the drag was started from an icon.
--   
--   By default, GTK+ uses the icon as the drag icon. You can use the
--   <a>Widget::dragBegin</a> signal to set a different icon. Note that you
--   have to use <tt><i>g_signal_connect_after()</i></tt> to ensure that
--   your signal handler gets executed after the default handler.
--   
--   <i>Since: 2.16</i>
entrySetIconDragSource :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> TargetList -> [DragAction] -> m ()

-- | Sets the icon shown in the entry at the specified position from the
--   current icon theme. If the icon isn’t known, a “broken image” icon
--   will be displayed instead.
--   
--   If <i><tt>icon</tt></i> is <a>Nothing</a>, no icon will be shown in
--   the specified position.
--   
--   <i>Since: 2.16</i>
entrySetIconFromGicon :: (HasCallStack, MonadIO m, IsEntry a, IsIcon b) => a -> EntryIconPosition -> Maybe b -> m ()

-- | Sets the icon shown in the entry at the specified position from the
--   current icon theme.
--   
--   If the icon name isn’t known, a “broken image” icon will be displayed
--   instead.
--   
--   If <i><tt>iconName</tt></i> is <a>Nothing</a>, no icon will be shown
--   in the specified position.
--   
--   <i>Since: 2.16</i>
entrySetIconFromIconName :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()

-- | Sets the icon shown in the specified position using a pixbuf.
--   
--   If <i><tt>pixbuf</tt></i> is <a>Nothing</a>, no icon will be shown in
--   the specified position.
--   
--   <i>Since: 2.16</i>
entrySetIconFromPixbuf :: (HasCallStack, MonadIO m, IsEntry a, IsPixbuf b) => a -> EntryIconPosition -> Maybe b -> m ()

-- | Sets the icon shown in the entry at the specified position from a
--   stock image.
--   
--   If <i><tt>stockId</tt></i> is <a>Nothing</a>, no icon will be shown in
--   the specified position.
--   
--   <i>Since: 2.16</i>
entrySetIconFromStock :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()

-- | Sets the sensitivity for the specified icon.
--   
--   <i>Since: 2.16</i>
entrySetIconSensitive :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Bool -> m ()

-- | Sets <i><tt>tooltip</tt></i> as the contents of the tooltip for the
--   icon at the specified position. <i><tt>tooltip</tt></i> is assumed to
--   be marked up with the [Pango text markup language][PangoMarkupFormat].
--   
--   Use <a>Nothing</a> for <i><tt>tooltip</tt></i> to remove an existing
--   tooltip.
--   
--   See also <a>widgetSetTooltipMarkup</a> and
--   <a>entrySetIconTooltipText</a>.
--   
--   <i>Since: 2.16</i>
entrySetIconTooltipMarkup :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()

-- | Sets <i><tt>tooltip</tt></i> as the contents of the tooltip for the
--   icon at the specified position.
--   
--   Use <a>Nothing</a> for <i><tt>tooltip</tt></i> to remove an existing
--   tooltip.
--   
--   See also <a>widgetSetTooltipText</a> and
--   <a>entrySetIconTooltipMarkup</a>.
--   
--   If you unset the widget tooltip via <a>widgetSetTooltipText</a> or
--   <a>widgetSetTooltipMarkup</a>, this sets GtkWidget:has-tooltip to
--   <a>False</a>, which suppresses icon tooltips too. You can resolve this
--   by then calling <a>widgetSetHasTooltip</a> to set
--   GtkWidget:has-tooltip back to <a>True</a>, or setting at least one
--   non-empty tooltip on any icon achieves the same result.
--   
--   <i>Since: 2.16</i>
entrySetIconTooltipText :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()

-- | Sets <tt><i>entry</i></tt>’s inner-border property to
--   <i><tt>border</tt></i>, or clears it if <a>Nothing</a> is passed. The
--   inner-border is the area around the entry’s text, but inside its
--   frame.
--   
--   If set, this property overrides the inner-border style property.
--   Overriding the style-provided border is useful when you want to do
--   in-place editing of some text in a canvas or list widget, where
--   pixel-exact positioning of the entry is important.
--   
--   <i>Since: 2.10</i>
entrySetInnerBorder :: (HasCallStack, MonadIO m, IsEntry a) => a -> Maybe Border -> m ()

-- | Sets the <a>Entry:inputHints</a> property, which allows input methods
--   to fine-tune their behaviour.
--   
--   <i>Since: 3.6</i>
entrySetInputHints :: (HasCallStack, MonadIO m, IsEntry a) => a -> [InputHints] -> m ()

-- | Sets the <a>Entry:inputPurpose</a> property which can be used by
--   on-screen keyboards and other input methods to adjust their behaviour.
--   
--   <i>Since: 3.6</i>
entrySetInputPurpose :: (HasCallStack, MonadIO m, IsEntry a) => a -> InputPurpose -> m ()

-- | Sets the character to use in place of the actual text when
--   <a>entrySetVisibility</a> has been called to set text visibility to
--   <a>False</a>. i.e. this is the character used in “password mode” to
--   show the user how many characters have been typed. By default, GTK+
--   picks the best invisible char available in the current font. If you
--   set the invisible char to 0, then the user will get no feedback at
--   all; there will be no text on the screen as they type.
entrySetInvisibleChar :: (HasCallStack, MonadIO m, IsEntry a) => a -> Char -> m ()

-- | Sets the maximum allowed length of the contents of the widget. If the
--   current contents are longer than the given length, then they will be
--   truncated to fit.
--   
--   This is equivalent to getting <i><tt>entry</tt></i>'s
--   <a>EntryBuffer</a> and calling <a>entryBufferSetMaxLength</a> on it.
--   ]|
entrySetMaxLength :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> m ()

-- | Sets the desired maximum width in characters of <i><tt>entry</tt></i>.
--   
--   <i>Since: 3.12</i>
entrySetMaxWidthChars :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> m ()

-- | Sets whether the text is overwritten when typing in the <a>Entry</a>.
--   
--   <i>Since: 2.14</i>
entrySetOverwriteMode :: (HasCallStack, MonadIO m, IsEntry a) => a -> Bool -> m ()

-- | Sets text to be displayed in <i><tt>entry</tt></i> when it is empty
--   and unfocused. This can be used to give a visual hint of the expected
--   contents of the <a>Entry</a>.
--   
--   Note that since the placeholder text gets removed when the entry
--   received focus, using this feature is a bit problematic if the entry
--   is given the initial focus in a window. Sometimes this can be worked
--   around by delaying the initial focus setting until the first key event
--   arrives.
--   
--   <i>Since: 3.2</i>
entrySetPlaceholderText :: (HasCallStack, MonadIO m, IsEntry a) => a -> Maybe Text -> m ()

-- | Causes the entry’s progress indicator to “fill in” the given fraction
--   of the bar. The fraction should be between 0.0 and 1.0, inclusive.
--   
--   <i>Since: 2.16</i>
entrySetProgressFraction :: (HasCallStack, MonadIO m, IsEntry a) => a -> Double -> m ()

-- | Sets the fraction of total entry width to move the progress bouncing
--   block for each call to <a>entryProgressPulse</a>.
--   
--   <i>Since: 2.16</i>
entrySetProgressPulseStep :: (HasCallStack, MonadIO m, IsEntry a) => a -> Double -> m ()

-- | Sets a <a>TabArray</a>; the tabstops in the array are applied to the
--   entry text.
--   
--   <i>Since: 3.10</i>
entrySetTabs :: (HasCallStack, MonadIO m, IsEntry a) => a -> TabArray -> m ()

-- | Sets the text in the widget to the given value, replacing the current
--   contents.
--   
--   See <a>entryBufferSetText</a>.
entrySetText :: (HasCallStack, MonadIO m, IsEntry a) => a -> Text -> m ()

-- | Sets whether the contents of the entry are visible or not. When
--   visibility is set to <a>False</a>, characters are displayed as the
--   invisible char, and will also appear that way when the text in the
--   entry widget is copied elsewhere.
--   
--   By default, GTK+ picks the best invisible character available in the
--   current font, but it can be changed with <a>entrySetInvisibleChar</a>.
--   
--   Note that you probably want to set <a>Entry:inputPurpose</a> to
--   <a>InputPurposePassword</a> or <a>InputPurposePin</a> to inform input
--   methods about the purpose of this entry, in addition to setting
--   visibility to <a>False</a>.
entrySetVisibility :: (HasCallStack, MonadIO m, IsEntry a) => a -> Bool -> m ()

-- | Changes the size request of the entry to be about the right size for
--   <i><tt>nChars</tt></i> characters. Note that it changes the size
--   request, the size can still be affected by how you pack the widget
--   into containers. If <i><tt>nChars</tt></i> is -1, the size reverts to
--   the default entry size.
entrySetWidthChars :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> m ()

-- | Converts from a position in the entry contents (returned by
--   <a>entryGetText</a>) to a position in the entry’s <a>Layout</a>
--   (returned by <a>entryGetLayout</a>, with text retrieved via
--   <a>layoutGetText</a>).
entryTextIndexToLayoutIndex :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> m Int32

-- | Unsets the invisible char previously set with
--   <a>entrySetInvisibleChar</a>. So that the default invisible char is
--   used again.
--   
--   <i>Since: 2.16</i>
entryUnsetInvisibleChar :: (HasCallStack, MonadIO m, IsEntry a) => a -> m ()

-- | Connect a signal handler for the <a>activateCurrent</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> menuShell #activateCurrent callback
--   </pre>
onMenuShellActivateCurrent :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellActivateCurrentCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateCurrent</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> menuShell #activateCurrent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuShellActivateCurrent :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellActivateCurrentCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cancel</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> menuShell #cancel callback
--   </pre>
onMenuShellCancel :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellCancelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cancel</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> menuShell #cancel callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuShellCancel :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellCancelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cycleFocus</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> menuShell #cycleFocus callback
--   </pre>
onMenuShellCycleFocus :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellCycleFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cycleFocus</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> menuShell #cycleFocus callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuShellCycleFocus :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellCycleFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deactivate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> menuShell #deactivate callback
--   </pre>
onMenuShellDeactivate :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellDeactivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deactivate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> menuShell #deactivate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuShellDeactivate :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellDeactivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insert</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> menuShell #insert callback
--   </pre>
onMenuShellInsert :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellInsertCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insert</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> menuShell #insert callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuShellInsert :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellInsertCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCurrent</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> menuShell #moveCurrent callback
--   </pre>
onMenuShellMoveCurrent :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellMoveCurrentCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCurrent</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> menuShell #moveCurrent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuShellMoveCurrent :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellMoveCurrentCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveSelected</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> menuShell #moveSelected callback
--   </pre>
onMenuShellMoveSelected :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellMoveSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveSelected</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> menuShell #moveSelected callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuShellMoveSelected :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellMoveSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionDone</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> menuShell #selectionDone callback
--   </pre>
onMenuShellSelectionDone :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellSelectionDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionDone</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> menuShell #selectionDone callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuShellSelectionDone :: (IsMenuShell a, MonadIO m) => a -> ((?self :: a) => MenuShellSelectionDoneCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>take-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuShell #takeFocus
--   </pre>
getMenuShellTakeFocus :: (MonadIO m, IsMenuShell o) => o -> m Bool

-- | Set the value of the “<tt>take-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuShell [ #takeFocus <a>:=</a> value ]
--   </pre>
setMenuShellTakeFocus :: (MonadIO m, IsMenuShell o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>take-focus</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructMenuShellTakeFocus :: (IsMenuShell o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Activates the menu item within the menu shell.
menuShellActivateItem :: (HasCallStack, MonadIO m, IsMenuShell a, IsWidget b) => a -> b -> Bool -> m ()

-- | Adds a new <a>MenuItem</a> to the end of the menu shell's item list.
menuShellAppend :: (HasCallStack, MonadIO m, IsMenuShell a, IsMenuItem b) => a -> b -> m ()

-- | Establishes a binding between a <a>MenuShell</a> and a
--   <a>MenuModel</a>.
--   
--   The contents of <i><tt>shell</tt></i> are removed and then refilled
--   with menu items according to <i><tt>model</tt></i>. When
--   <i><tt>model</tt></i> changes, <i><tt>shell</tt></i> is updated.
--   Calling this function twice on <i><tt>shell</tt></i> with different
--   <i><tt>model</tt></i> will cause the first binding to be replaced with
--   a binding to the new model. If <i><tt>model</tt></i> is <a>Nothing</a>
--   then any previous binding is undone and all children are removed.
--   
--   <i><tt>withSeparators</tt></i> determines if toplevel items (eg:
--   sections) have separators inserted between them. This is typically
--   desired for menus but doesn’t make sense for menubars.
--   
--   If <i><tt>actionNamespace</tt></i> is non-<a>Nothing</a> then the
--   effect is as if all actions mentioned in the <i><tt>model</tt></i>
--   have their names prefixed with the namespace, plus a dot. For example,
--   if the action “quit” is mentioned and <i><tt>actionNamespace</tt></i>
--   is “app” then the effective action name is “app.quit”.
--   
--   This function uses <a>Actionable</a> to define the action name and
--   target values on the created menu items. If you want to use an action
--   group other than “app” and “win”, or if you want to use a
--   <a>MenuShell</a> outside of a <a>ApplicationWindow</a>, then you will
--   need to attach your own action group to the widget hierarchy using
--   <a>widgetInsertActionGroup</a>. As an example, if you created a group
--   with a “quit” action and inserted it with the name “mygroup” then you
--   would use the action name “mygroup.quit” in your <a>MenuModel</a>.
--   
--   For most cases you are probably better off using
--   <a>menuNewFromModel</a> or <a>menuBarNewFromModel</a> or just directly
--   passing the <a>MenuModel</a> to <a>applicationSetAppMenu</a> or
--   <a>applicationSetMenubar</a>.
--   
--   <i>Since: 3.6</i>
menuShellBindModel :: (HasCallStack, MonadIO m, IsMenuShell a, IsMenuModel b) => a -> Maybe b -> Maybe Text -> Bool -> m ()

-- | Cancels the selection within the menu shell.
--   
--   <i>Since: 2.4</i>
menuShellCancel :: (HasCallStack, MonadIO m, IsMenuShell a) => a -> m ()

-- | Deactivates the menu shell.
--   
--   Typically this results in the menu shell being erased from the screen.
menuShellDeactivate :: (HasCallStack, MonadIO m, IsMenuShell a) => a -> m ()

-- | Deselects the currently selected item from the menu shell, if any.
menuShellDeselect :: (HasCallStack, MonadIO m, IsMenuShell a) => a -> m ()

-- | Gets the parent menu shell.
--   
--   The parent menu shell of a submenu is the <a>Menu</a> or
--   <a>MenuBar</a> from which it was opened up.
--   
--   <i>Since: 3.0</i>
menuShellGetParentShell :: (HasCallStack, MonadIO m, IsMenuShell a) => a -> m Widget

-- | Gets the currently selected item.
--   
--   <i>Since: 3.0</i>
menuShellGetSelectedItem :: (HasCallStack, MonadIO m, IsMenuShell a) => a -> m Widget

-- | Returns <a>True</a> if the menu shell will take the keyboard focus on
--   popup.
--   
--   <i>Since: 2.8</i>
menuShellGetTakeFocus :: (HasCallStack, MonadIO m, IsMenuShell a) => a -> m Bool

-- | Adds a new <a>MenuItem</a> to the menu shell’s item list at the
--   position indicated by <i><tt>position</tt></i>.
menuShellInsert :: (HasCallStack, MonadIO m, IsMenuShell a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Adds a new <a>MenuItem</a> to the beginning of the menu shell's item
--   list.
menuShellPrepend :: (HasCallStack, MonadIO m, IsMenuShell a, IsWidget b) => a -> b -> m ()

-- | Select the first visible or selectable child of the menu shell; don’t
--   select tearoff items unless the only item is a tearoff item.
--   
--   <i>Since: 2.2</i>
menuShellSelectFirst :: (HasCallStack, MonadIO m, IsMenuShell a) => a -> Bool -> m ()

-- | Selects the menu item from the menu shell.
menuShellSelectItem :: (HasCallStack, MonadIO m, IsMenuShell a, IsWidget b) => a -> b -> m ()

-- | If <i><tt>takeFocus</tt></i> is <a>True</a> (the default) the menu
--   shell will take the keyboard focus so that it will receive all
--   keyboard events which is needed to enable keyboard navigation in
--   menus.
--   
--   Setting <i><tt>takeFocus</tt></i> to <a>False</a> is useful only for
--   special applications like virtual keyboard implementations which
--   should not take keyboard focus.
--   
--   The <i><tt>takeFocus</tt></i> state of a menu or menu bar is
--   automatically propagated to submenus whenever a submenu is popped up,
--   so you don’t have to worry about recursively setting it for your
--   entire menu hierarchy. Only when programmatically picking a submenu
--   and popping it up manually, the <i><tt>takeFocus</tt></i> property of
--   the submenu needs to be set explicitly.
--   
--   Note that setting it to <a>False</a> has side-effects:
--   
--   If the focus is in some other app, it keeps the focus and keynav in
--   the menu doesn’t work. Consequently, keynav on the menu will only work
--   if the focus is on some toplevel owned by the onscreen keyboard.
--   
--   To avoid confusing the user, menus with <i><tt>takeFocus</tt></i> set
--   to <a>False</a> should not display mnemonics or accelerators, since it
--   cannot be guaranteed that they will work.
--   
--   See also <a>keyboardGrab</a>
--   
--   <i>Since: 2.8</i>
menuShellSetTakeFocus :: (HasCallStack, MonadIO m, IsMenuShell a) => a -> Bool -> m ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> menuItem #activate callback
--   </pre>
onMenuItemActivate :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> menuItem #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuItemActivate :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateItem</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> menuItem #activateItem callback
--   </pre>
onMenuItemActivateItem :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemActivateItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateItem</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> menuItem #activateItem callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuItemActivateItem :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemActivateItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deselect</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> menuItem #deselect callback
--   </pre>
onMenuItemDeselect :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemDeselectCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deselect</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> menuItem #deselect callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuItemDeselect :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemDeselectCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>select</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> menuItem #select callback
--   </pre>
onMenuItemSelect :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemSelectCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>select</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> menuItem #select callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuItemSelect :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemSelectCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleSizeAllocate</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> menuItem #toggleSizeAllocate callback
--   </pre>
onMenuItemToggleSizeAllocate :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemToggleSizeAllocateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleSizeAllocate</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> menuItem #toggleSizeAllocate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuItemToggleSizeAllocate :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemToggleSizeAllocateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleSizeRequest</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> menuItem #toggleSizeRequest callback
--   </pre>
onMenuItemToggleSizeRequest :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemToggleSizeRequestCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleSizeRequest</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> menuItem #toggleSizeRequest callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuItemToggleSizeRequest :: (IsMenuItem a, MonadIO m) => a -> ((?self :: a) => MenuItemToggleSizeRequestCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>accel-path</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuItem #accelPath
--   </pre>
getMenuItemAccelPath :: (MonadIO m, IsMenuItem o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>accel-path</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuItem [ #accelPath <a>:=</a> value ]
--   </pre>
setMenuItemAccelPath :: (MonadIO m, IsMenuItem o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-path</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructMenuItemAccelPath :: (IsMenuItem o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>accel-path</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #accelPath
--   </pre>
clearMenuItemAccelPath :: (MonadIO m, IsMenuItem o) => o -> m ()

-- | Get the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuItem #label
--   </pre>
getMenuItemLabel :: (MonadIO m, IsMenuItem o) => o -> m Text

-- | Set the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuItem [ #label <a>:=</a> value ]
--   </pre>
setMenuItemLabel :: (MonadIO m, IsMenuItem o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMenuItemLabel :: (IsMenuItem o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>right-justified</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuItem #rightJustified
--   </pre>
getMenuItemRightJustified :: (MonadIO m, IsMenuItem o) => o -> m Bool

-- | Set the value of the “<tt>right-justified</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuItem [ #rightJustified <a>:=</a> value ]
--   </pre>
setMenuItemRightJustified :: (MonadIO m, IsMenuItem o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>right-justified</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructMenuItemRightJustified :: (IsMenuItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>submenu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuItem #submenu
--   </pre>
getMenuItemSubmenu :: (MonadIO m, IsMenuItem o) => o -> m (Maybe Menu)

-- | Set the value of the “<tt>submenu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuItem [ #submenu <a>:=</a> value ]
--   </pre>
setMenuItemSubmenu :: (MonadIO m, IsMenuItem o, IsMenu a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>submenu</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMenuItemSubmenu :: (IsMenuItem o, MonadIO m, IsMenu a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>submenu</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #submenu
--   </pre>
clearMenuItemSubmenu :: (MonadIO m, IsMenuItem o) => o -> m ()

-- | Get the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuItem #useUnderline
--   </pre>
getMenuItemUseUnderline :: (MonadIO m, IsMenuItem o) => o -> m Bool

-- | Set the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuItem [ #useUnderline <a>:=</a> value ]
--   </pre>
setMenuItemUseUnderline :: (MonadIO m, IsMenuItem o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-underline</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructMenuItemUseUnderline :: (IsMenuItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>MenuItem</a>.
menuItemNew :: (HasCallStack, MonadIO m) => m MenuItem

-- | Creates a new <a>MenuItem</a> whose child is a <a>Label</a>.
menuItemNewWithLabel :: (HasCallStack, MonadIO m) => Text -> m MenuItem

-- | Creates a new <a>MenuItem</a> containing a label.
--   
--   The label will be created using <a>labelNewWithMnemonic</a>, so
--   underscores in <i><tt>label</tt></i> indicate the mnemonic for the
--   menu item.
menuItemNewWithMnemonic :: (HasCallStack, MonadIO m) => Text -> m MenuItem

-- | Emits the <a>MenuItem::activate</a> signal on the given item
menuItemActivate :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> m ()

-- | Emits the <a>MenuItem::deselect</a> signal on the given item.
menuItemDeselect :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> m ()

-- | Retrieve the accelerator path that was previously set on
--   <i><tt>menuItem</tt></i>.
--   
--   See <a>menuItemSetAccelPath</a> for details.
--   
--   <i>Since: 2.14</i>
menuItemGetAccelPath :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> m (Maybe Text)

-- | Sets <i><tt>text</tt></i> on the <i><tt>menuItem</tt></i> label
--   
--   <i>Since: 2.16</i>
menuItemGetLabel :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> m Text

-- | Returns whether the <i><tt>menuItem</tt></i> reserves space for the
--   submenu indicator, regardless if it has a submenu or not.
--   
--   <i>Since: 3.0</i>
menuItemGetReserveIndicator :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> m Bool

-- | Gets whether the menu item appears justified at the right side of the
--   menu bar.
menuItemGetRightJustified :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> m Bool

-- | Gets the submenu underneath this menu item, if any. See
--   <a>menuItemSetSubmenu</a>.
menuItemGetSubmenu :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> m (Maybe Widget)

-- | Checks if an underline in the text indicates the next character should
--   be used for the mnemonic accelerator key.
--   
--   <i>Since: 2.16</i>
menuItemGetUseUnderline :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> m Bool

-- | Emits the <a>MenuItem::select</a> signal on the given item.
menuItemSelect :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> m ()

-- | Sets whether the <i><tt>menuItem</tt></i> should reserve space for the
--   submenu indicator, regardless if it actually has a submenu or not.
--   
--   There should be little need for applications to call this functions.
--   
--   <i>Since: 3.0</i>
menuItemSetReserveIndicator :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> Bool -> m ()

-- | Sets whether the menu item appears justified at the right side of a
--   menu bar. This was traditionally done for “Help” menu items, but is
--   now considered a bad idea. (If the widget layout is reversed for a
--   right-to-left language like Hebrew or Arabic,
--   right-justified-menu-items appear at the left.)
menuItemSetRightJustified :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> Bool -> m ()

-- | Sets or replaces the menu item’s submenu, or removes it when a
--   <a>Nothing</a> submenu is passed.
menuItemSetSubmenu :: (HasCallStack, MonadIO m, IsMenuItem a, IsMenu b) => a -> Maybe b -> m ()

-- | If true, an underline in the text indicates the next character should
--   be used for the mnemonic accelerator key.
--   
--   <i>Since: 2.16</i>
menuItemSetUseUnderline :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> Bool -> m ()

-- | Emits the <a>MenuItem::toggleSizeAllocate</a> signal on the given
--   item.
menuItemToggleSizeAllocate :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> Int32 -> m ()

-- | Emits the <a>MenuItem::toggleSizeRequest</a> signal on the given item.
menuItemToggleSizeRequest :: (HasCallStack, MonadIO m, IsMenuItem a) => a -> Int32 -> m Int32

-- | Connect a signal handler for the <a>moveScroll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> menu #moveScroll callback
--   </pre>
onMenuMoveScroll :: (IsMenu a, MonadIO m) => a -> ((?self :: a) => MenuMoveScrollCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveScroll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> menu #moveScroll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuMoveScroll :: (IsMenu a, MonadIO m) => a -> ((?self :: a) => MenuMoveScrollCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>poppedUp</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> menu #poppedUp callback
--   </pre>
onMenuPoppedUp :: (IsMenu a, MonadIO m) => a -> ((?self :: a) => MenuPoppedUpCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>poppedUp</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> menu #poppedUp callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuPoppedUp :: (IsMenu a, MonadIO m) => a -> ((?self :: a) => MenuPoppedUpCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>accel-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menu #accelGroup
--   </pre>
getMenuAccelGroup :: (MonadIO m, IsMenu o) => o -> m AccelGroup

-- | Set the value of the “<tt>accel-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menu [ #accelGroup <a>:=</a> value ]
--   </pre>
setMenuAccelGroup :: (MonadIO m, IsMenu o, IsAccelGroup a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-group</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructMenuAccelGroup :: (IsMenu o, MonadIO m, IsAccelGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>accel-group</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #accelGroup
--   </pre>
clearMenuAccelGroup :: (MonadIO m, IsMenu o) => o -> m ()

-- | Get the value of the “<tt>accel-path</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menu #accelPath
--   </pre>
getMenuAccelPath :: (MonadIO m, IsMenu o) => o -> m Text

-- | Set the value of the “<tt>accel-path</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menu [ #accelPath <a>:=</a> value ]
--   </pre>
setMenuAccelPath :: (MonadIO m, IsMenu o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-path</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructMenuAccelPath :: (IsMenu o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>accel-path</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #accelPath
--   </pre>
clearMenuAccelPath :: (MonadIO m, IsMenu o) => o -> m ()

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menu #active
--   </pre>
getMenuActive :: (MonadIO m, IsMenu o) => o -> m Int32

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menu [ #active <a>:=</a> value ]
--   </pre>
setMenuActive :: (MonadIO m, IsMenu o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMenuActive :: (IsMenu o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>anchor-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menu #anchorHints
--   </pre>
getMenuAnchorHints :: (MonadIO m, IsMenu o) => o -> m [AnchorHints]

-- | Set the value of the “<tt>anchor-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menu [ #anchorHints <a>:=</a> value ]
--   </pre>
setMenuAnchorHints :: (MonadIO m, IsMenu o) => o -> [AnchorHints] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>anchor-hints</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructMenuAnchorHints :: (IsMenu o, MonadIO m) => [AnchorHints] -> m (GValueConstruct o)

-- | Get the value of the “<tt>attach-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menu #attachWidget
--   </pre>
getMenuAttachWidget :: (MonadIO m, IsMenu o) => o -> m Widget

-- | Set the value of the “<tt>attach-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menu [ #attachWidget <a>:=</a> value ]
--   </pre>
setMenuAttachWidget :: (MonadIO m, IsMenu o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>attach-widget</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructMenuAttachWidget :: (IsMenu o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>attach-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #attachWidget
--   </pre>
clearMenuAttachWidget :: (MonadIO m, IsMenu o) => o -> m ()

-- | Get the value of the “<tt>menu-type-hint</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menu #menuTypeHint
--   </pre>
getMenuMenuTypeHint :: (MonadIO m, IsMenu o) => o -> m WindowTypeHint

-- | Set the value of the “<tt>menu-type-hint</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menu [ #menuTypeHint <a>:=</a> value ]
--   </pre>
setMenuMenuTypeHint :: (MonadIO m, IsMenu o) => o -> WindowTypeHint -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>menu-type-hint</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructMenuMenuTypeHint :: (IsMenu o, MonadIO m) => WindowTypeHint -> m (GValueConstruct o)

-- | Get the value of the “<tt>monitor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menu #monitor
--   </pre>
getMenuMonitor :: (MonadIO m, IsMenu o) => o -> m Int32

-- | Set the value of the “<tt>monitor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menu [ #monitor <a>:=</a> value ]
--   </pre>
setMenuMonitor :: (MonadIO m, IsMenu o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>monitor</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMenuMonitor :: (IsMenu o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>rect-anchor-dx</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menu #rectAnchorDx
--   </pre>
getMenuRectAnchorDx :: (MonadIO m, IsMenu o) => o -> m Int32

-- | Set the value of the “<tt>rect-anchor-dx</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menu [ #rectAnchorDx <a>:=</a> value ]
--   </pre>
setMenuRectAnchorDx :: (MonadIO m, IsMenu o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rect-anchor-dx</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructMenuRectAnchorDx :: (IsMenu o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>rect-anchor-dy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menu #rectAnchorDy
--   </pre>
getMenuRectAnchorDy :: (MonadIO m, IsMenu o) => o -> m Int32

-- | Set the value of the “<tt>rect-anchor-dy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menu [ #rectAnchorDy <a>:=</a> value ]
--   </pre>
setMenuRectAnchorDy :: (MonadIO m, IsMenu o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rect-anchor-dy</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructMenuRectAnchorDy :: (IsMenu o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>reserve-toggle-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menu #reserveToggleSize
--   </pre>
getMenuReserveToggleSize :: (MonadIO m, IsMenu o) => o -> m Bool

-- | Set the value of the “<tt>reserve-toggle-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menu [ #reserveToggleSize <a>:=</a> value ]
--   </pre>
setMenuReserveToggleSize :: (MonadIO m, IsMenu o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>reserve-toggle-size</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructMenuReserveToggleSize :: (IsMenu o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>tearoff-state</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menu #tearoffState
--   </pre>
getMenuTearoffState :: (MonadIO m, IsMenu o) => o -> m Bool

-- | Set the value of the “<tt>tearoff-state</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menu [ #tearoffState <a>:=</a> value ]
--   </pre>
setMenuTearoffState :: (MonadIO m, IsMenu o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tearoff-state</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructMenuTearoffState :: (IsMenu o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>tearoff-title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menu #tearoffTitle
--   </pre>
getMenuTearoffTitle :: (MonadIO m, IsMenu o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>tearoff-title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menu [ #tearoffTitle <a>:=</a> value ]
--   </pre>
setMenuTearoffTitle :: (MonadIO m, IsMenu o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tearoff-title</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructMenuTearoffTitle :: (IsMenu o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>tearoff-title</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #tearoffTitle
--   </pre>
clearMenuTearoffTitle :: (MonadIO m, IsMenu o) => o -> m ()

-- | Creates a new <a>Menu</a>
menuNew :: (HasCallStack, MonadIO m) => m Menu

-- | Adds a new <a>MenuItem</a> to a (table) menu. The number of “cells”
--   that an item will occupy is specified by <i><tt>leftAttach</tt></i>,
--   <i><tt>rightAttach</tt></i>, <i><tt>topAttach</tt></i> and
--   <i><tt>bottomAttach</tt></i>. These each represent the leftmost,
--   rightmost, uppermost and lower column and row numbers of the table.
--   (Columns and rows are indexed from zero).
--   
--   Note that this function is not related to <a>menuDetach</a>.
--   
--   <i>Since: 2.4</i>
menuAttach :: (HasCallStack, MonadIO m, IsMenu a, IsWidget b) => a -> b -> Word32 -> Word32 -> Word32 -> Word32 -> m ()

-- | Detaches the menu from the widget to which it had been attached. This
--   function will call the callback function, <i><tt>detacher</tt></i>,
--   provided when the <a>menuAttachToWidget</a> function was called.
menuDetach :: (HasCallStack, MonadIO m, IsMenu a) => a -> m ()

-- | Gets the <a>AccelGroup</a> which holds global accelerators for the
--   menu. See <a>menuSetAccelGroup</a>.
menuGetAccelGroup :: (HasCallStack, MonadIO m, IsMenu a) => a -> m AccelGroup

-- | Retrieves the accelerator path set on the menu.
--   
--   <i>Since: 2.14</i>
menuGetAccelPath :: (HasCallStack, MonadIO m, IsMenu a) => a -> m Text

-- | Returns the selected menu item from the menu. This is used by the
--   <a>ComboBox</a>.
menuGetActive :: (HasCallStack, MonadIO m, IsMenu a) => a -> m Widget

-- | Returns the <a>Widget</a> that the menu is attached to.
menuGetAttachWidget :: (HasCallStack, MonadIO m, IsMenu a) => a -> m Widget

-- | Retrieves the number of the monitor on which to show the menu.
--   
--   <i>Since: 2.14</i>
menuGetMonitor :: (HasCallStack, MonadIO m, IsMenu a) => a -> m Int32

-- | Returns whether the menu reserves space for toggles and icons,
--   regardless of their actual presence.
--   
--   <i>Since: 2.18</i>
menuGetReserveToggleSize :: (HasCallStack, MonadIO m, IsMenu a) => a -> m Bool

-- | Returns whether the menu is torn off. See <a>menuSetTearoffState</a>.
menuGetTearoffState :: (HasCallStack, MonadIO m, IsMenu a) => a -> m Bool

-- | Returns the title of the menu. See <a>menuSetTitle</a>.
menuGetTitle :: (HasCallStack, MonadIO m, IsMenu a) => a -> m Text

-- | Places <i><tt>menu</tt></i> on the given monitor.
--   
--   <i>Since: 3.22</i>
menuPlaceOnMonitor :: (HasCallStack, MonadIO m, IsMenu a, IsMonitor b) => a -> b -> m ()

-- | Removes the menu from the screen.
menuPopdown :: (HasCallStack, MonadIO m, IsMenu a) => a -> m ()

-- | Displays <i><tt>menu</tt></i> and makes it available for selection.
--   
--   See gtk_menu_popup_at_widget () to pop up a menu at a widget.
--   gtk_menu_popup_at_rect () also allows you to position a menu at an
--   arbitrary rectangle.
--   
--   <i><tt>menu</tt></i> will be positioned at the pointer associated with
--   <i><tt>triggerEvent</tt></i>.
--   
--   Properties that influence the behaviour of this function are
--   <a>Menu:anchorHints</a>, <a>Menu:rectAnchorDx</a>,
--   <a>Menu:rectAnchorDy</a>, and <a>Menu:menuTypeHint</a>. Connect to the
--   <a>Menu::poppedUp</a> signal to find out how it was actually
--   positioned.
--   
--   <i>Since: 3.22</i>
menuPopupAtPointer :: (HasCallStack, MonadIO m, IsMenu a) => a -> Maybe Event -> m ()

-- | Displays <i><tt>menu</tt></i> and makes it available for selection.
--   
--   See gtk_menu_popup_at_widget () and gtk_menu_popup_at_pointer (),
--   which handle more common cases for popping up menus.
--   
--   <i><tt>menu</tt></i> will be positioned at <i><tt>rect</tt></i>,
--   aligning their anchor points. <i><tt>rect</tt></i> is relative to the
--   top-left corner of <i><tt>rectWindow</tt></i>.
--   <i><tt>rectAnchor</tt></i> and <i><tt>menuAnchor</tt></i> determine
--   anchor points on <i><tt>rect</tt></i> and <i><tt>menu</tt></i> to pin
--   together. <i><tt>menu</tt></i> can optionally be offset by
--   <a>Menu:rectAnchorDx</a> and <a>Menu:rectAnchorDy</a>.
--   
--   Anchors should be specified under the assumption that the text
--   direction is left-to-right; they will be flipped horizontally
--   automatically if the text direction is right-to-left.
--   
--   Other properties that influence the behaviour of this function are
--   <a>Menu:anchorHints</a> and <a>Menu:menuTypeHint</a>. Connect to the
--   <a>Menu::poppedUp</a> signal to find out how it was actually
--   positioned.
--   
--   <i>Since: 3.22</i>
menuPopupAtRect :: (HasCallStack, MonadIO m, IsMenu a, IsWindow b) => a -> b -> Rectangle -> Gravity -> Gravity -> Maybe Event -> m ()

-- | Displays <i><tt>menu</tt></i> and makes it available for selection.
--   
--   See gtk_menu_popup_at_pointer () to pop up a menu at the master
--   pointer. gtk_menu_popup_at_rect () also allows you to position a menu
--   at an arbitrary rectangle.
--   
--   
--   <i><tt>menu</tt></i> will be positioned at <i><tt>widget</tt></i>,
--   aligning their anchor points. <i><tt>widgetAnchor</tt></i> and
--   <i><tt>menuAnchor</tt></i> determine anchor points on
--   <i><tt>widget</tt></i> and <i><tt>menu</tt></i> to pin together.
--   <i><tt>menu</tt></i> can optionally be offset by
--   <a>Menu:rectAnchorDx</a> and <a>Menu:rectAnchorDy</a>.
--   
--   Anchors should be specified under the assumption that the text
--   direction is left-to-right; they will be flipped horizontally
--   automatically if the text direction is right-to-left.
--   
--   Other properties that influence the behaviour of this function are
--   <a>Menu:anchorHints</a> and <a>Menu:menuTypeHint</a>. Connect to the
--   <a>Menu::poppedUp</a> signal to find out how it was actually
--   positioned.
--   
--   <i>Since: 3.22</i>
menuPopupAtWidget :: (HasCallStack, MonadIO m, IsMenu a, IsWidget b) => a -> b -> Gravity -> Gravity -> Maybe Event -> m ()

-- | Displays a menu and makes it available for selection.
--   
--   Applications can use this function to display context-sensitive menus,
--   and will typically supply <a>Nothing</a> for the
--   <i><tt>parentMenuShell</tt></i>, <i><tt>parentMenuItem</tt></i>,
--   <i><tt>func</tt></i>, <i><tt>data</tt></i> and <i><tt>destroy</tt></i>
--   parameters. The default menu positioning function will position the
--   menu at the current position of <i><tt>device</tt></i> (or its
--   corresponding pointer).
--   
--   The <i><tt>button</tt></i> parameter should be the mouse button
--   pressed to initiate the menu popup. If the menu popup was initiated by
--   something other than a mouse button press, such as a mouse button
--   release or a keypress, <i><tt>button</tt></i> should be 0.
--   
--   The <i><tt>activateTime</tt></i> parameter is used to conflict-resolve
--   initiation of concurrent requests for mouse/keyboard grab requests. To
--   function properly, this needs to be the time stamp of the user event
--   (such as a mouse click or key press) that caused the initiation of the
--   popup. Only if no such event is available, <a>getCurrentEventTime</a>
--   can be used instead.
--   
--   Note that this function does not work very well on GDK backends that
--   do not have global coordinates, such as Wayland or Mir. You should
--   probably use one of the gtk_menu_popup_at_ variants, which do not have
--   this problem.
--   
--   <i>Since: 3.0</i>
menuPopupForDevice :: (HasCallStack, MonadIO m, IsMenu a, IsDevice b, IsWidget c, IsWidget d) => a -> Maybe b -> Maybe c -> Maybe d -> Maybe MenuPositionFunc -> Word32 -> Word32 -> m ()

-- | Moves <i><tt>child</tt></i> to a new <i><tt>position</tt></i> in the
--   list of <i><tt>menu</tt></i> children.
menuReorderChild :: (HasCallStack, MonadIO m, IsMenu a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Repositions the menu according to its position function.
menuReposition :: (HasCallStack, MonadIO m, IsMenu a) => a -> m ()

-- | Selects the specified menu item within the menu. This is used by the
--   <a>ComboBox</a> and should not be used by anyone else.
menuSetActive :: (HasCallStack, MonadIO m, IsMenu a) => a -> Word32 -> m ()

-- | Sets whether the menu should reserve space for drawing toggles or
--   icons, regardless of their actual presence.
--   
--   <i>Since: 2.18</i>
menuSetReserveToggleSize :: (HasCallStack, MonadIO m, IsMenu a) => a -> Bool -> m ()

-- | Sets the <a>Screen</a> on which the menu will be displayed.
--   
--   <i>Since: 2.2</i>
menuSetScreen :: (HasCallStack, MonadIO m, IsMenu a, IsScreen b) => a -> Maybe b -> m ()

-- | Changes the tearoff state of the menu. A menu is normally displayed as
--   drop down menu which persists as long as the menu is active. It can
--   also be displayed as a tearoff menu which persists until it is closed
--   or reattached.
menuSetTearoffState :: (HasCallStack, MonadIO m, IsMenu a) => a -> Bool -> m ()

-- | Sets the title string for the menu.
--   
--   The title is displayed when the menu is shown as a tearoff menu. If
--   <i><tt>title</tt></i> is <a>Nothing</a>, the menu will see if it is
--   attached to a parent menu item, and if so it will try to use the same
--   text as that menu item’s label.
menuSetTitle :: (HasCallStack, MonadIO m, IsMenu a) => a -> Maybe Text -> m ()

-- | Returns a list of the menus which are attached to this widget. This
--   list is owned by GTK+ and must not be modified.
--   
--   <i>Since: 2.6</i>
menuGetForAttachWidget :: (HasCallStack, MonadIO m, IsWidget a) => a -> m [Widget]

-- | Connect a signal handler for the <a>connectProxy</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> actionGroup #connectProxy callback
--   </pre>
onActionGroupConnectProxy :: (IsActionGroup a, MonadIO m) => a -> ((?self :: a) => ActionGroupConnectProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>connectProxy</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> actionGroup #connectProxy callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterActionGroupConnectProxy :: (IsActionGroup a, MonadIO m) => a -> ((?self :: a) => ActionGroupConnectProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>disconnectProxy</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> actionGroup #disconnectProxy callback
--   </pre>
onActionGroupDisconnectProxy :: (IsActionGroup a, MonadIO m) => a -> ((?self :: a) => ActionGroupDisconnectProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>disconnectProxy</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> actionGroup #disconnectProxy callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterActionGroupDisconnectProxy :: (IsActionGroup a, MonadIO m) => a -> ((?self :: a) => ActionGroupDisconnectProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>postActivate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> actionGroup #postActivate callback
--   </pre>
onActionGroupPostActivate :: (IsActionGroup a, MonadIO m) => a -> ((?self :: a) => ActionGroupPostActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>postActivate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> actionGroup #postActivate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterActionGroupPostActivate :: (IsActionGroup a, MonadIO m) => a -> ((?self :: a) => ActionGroupPostActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preActivate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> actionGroup #preActivate callback
--   </pre>
onActionGroupPreActivate :: (IsActionGroup a, MonadIO m) => a -> ((?self :: a) => ActionGroupPreActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preActivate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> actionGroup #preActivate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterActionGroupPreActivate :: (IsActionGroup a, MonadIO m) => a -> ((?self :: a) => ActionGroupPreActivateCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>accel-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionGroup #accelGroup
--   </pre>
getActionGroupAccelGroup :: (MonadIO m, IsActionGroup o) => o -> m AccelGroup

-- | Set the value of the “<tt>accel-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionGroup [ #accelGroup <a>:=</a> value ]
--   </pre>
setActionGroupAccelGroup :: (MonadIO m, IsActionGroup o, IsAccelGroup a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-group</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructActionGroupAccelGroup :: (IsActionGroup o, MonadIO m, IsAccelGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>accel-group</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #accelGroup
--   </pre>
clearActionGroupAccelGroup :: (MonadIO m, IsActionGroup o) => o -> m ()

-- | Get the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionGroup #name
--   </pre>
getActionGroupName :: (MonadIO m, IsActionGroup o) => o -> m Text

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>name</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructActionGroupName :: (IsActionGroup o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionGroup #sensitive
--   </pre>
getActionGroupSensitive :: (MonadIO m, IsActionGroup o) => o -> m Bool

-- | Set the value of the “<tt>sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionGroup [ #sensitive <a>:=</a> value ]
--   </pre>
setActionGroupSensitive :: (MonadIO m, IsActionGroup o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sensitive</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructActionGroupSensitive :: (IsActionGroup o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionGroup #visible
--   </pre>
getActionGroupVisible :: (MonadIO m, IsActionGroup o) => o -> m Bool

-- | Set the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionGroup [ #visible <a>:=</a> value ]
--   </pre>
setActionGroupVisible :: (MonadIO m, IsActionGroup o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructActionGroupVisible :: (IsActionGroup o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>ActionGroup</a> object. The name of the action group
--   is used when associating [keybindings][Action-Accel] with the actions.
--   
--   <i>Since: 2.4</i>
actionGroupNew :: (HasCallStack, MonadIO m) => Text -> m ActionGroup

-- | Adds an action object to the action group. Note that this function
--   does not set up the accel path of the action, which can lead to
--   problems if a user tries to modify the accelerator of a menuitem
--   associated with the action. Therefore you must either set the accel
--   path yourself with <a>actionSetAccelPath</a>, or use
--   <tt>gtk_action_group_add_action_with_accel (..., NULL)</tt>.
--   
--   <i>Since: 2.4</i>
actionGroupAddAction :: (HasCallStack, MonadIO m, IsActionGroup a, IsAction b) => a -> b -> m ()

-- | Gets the accelerator group.
--   
--   <i>Since: 3.6</i>
actionGroupGetAccelGroup :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> m AccelGroup

-- | Looks up an action in the action group by name.
--   
--   <i>Since: 2.4</i>
actionGroupGetAction :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> Text -> m (Maybe Action)

-- | Gets the name of the action group.
--   
--   <i>Since: 2.4</i>
actionGroupGetName :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> m Text

-- | Returns <a>True</a> if the group is sensitive. The constituent actions
--   can only be logically sensitive (see <a>actionIsSensitive</a>) if they
--   are sensitive (see <a>actionGetSensitive</a>) and their group is
--   sensitive.
--   
--   <i>Since: 2.4</i>
actionGroupGetSensitive :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> m Bool

-- | Returns <a>True</a> if the group is visible. The constituent actions
--   can only be logically visible (see <a>actionIsVisible</a>) if they are
--   visible (see <a>actionGetVisible</a>) and their group is visible.
--   
--   <i>Since: 2.4</i>
actionGroupGetVisible :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> m Bool

-- | Lists the actions in the action group.
--   
--   <i>Since: 2.4</i>
actionGroupListActions :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> m [Action]

-- | Removes an action object from the action group.
--   
--   <i>Since: 2.4</i>
actionGroupRemoveAction :: (HasCallStack, MonadIO m, IsActionGroup a, IsAction b) => a -> b -> m ()

-- | Sets the accelerator group to be used by every action in this group.
--   
--   <i>Since: 3.6</i>
actionGroupSetAccelGroup :: (HasCallStack, MonadIO m, IsActionGroup a, IsAccelGroup b) => a -> Maybe b -> m ()

-- | Changes the sensitivity of <i><tt>actionGroup</tt></i>
--   
--   <i>Since: 2.4</i>
actionGroupSetSensitive :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> Bool -> m ()

-- | Sets a function to be used for translating the <i><tt>label</tt></i>
--   and <i><tt>tooltip</tt></i> of <tt><i>GtkActionEntrys</i></tt> added
--   by <tt><i>gtk_action_group_add_actions()</i></tt>.
--   
--   If you’re using <tt><i>gettext()</i></tt>, it is enough to set the
--   translation domain with <a>actionGroupSetTranslationDomain</a>.
--   
--   <i>Since: 2.4</i>
actionGroupSetTranslateFunc :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> TranslateFunc -> m ()

-- | Sets the translation domain and uses <a>dgettext</a> for translating
--   the <i><tt>label</tt></i> and <i><tt>tooltip</tt></i> of
--   <tt><i>GtkActionEntrys</i></tt> added by
--   <tt><i>gtk_action_group_add_actions()</i></tt>.
--   
--   If you’re not using <tt><i>gettext()</i></tt> for localization, see
--   <a>actionGroupSetTranslateFunc</a>.
--   
--   <i>Since: 2.4</i>
actionGroupSetTranslationDomain :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> Maybe Text -> m ()

-- | Changes the visible of <i><tt>actionGroup</tt></i>.
--   
--   <i>Since: 2.4</i>
actionGroupSetVisible :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> Bool -> m ()

-- | Translates a string using the function set with
--   <a>actionGroupSetTranslateFunc</a>. This is mainly intended for
--   language bindings.
--   
--   <i>Since: 2.6</i>
actionGroupTranslateString :: (HasCallStack, MonadIO m, IsActionGroup a) => a -> Text -> m Text

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> action #activate callback
--   </pre>
onActionActivate :: (IsAction a, MonadIO m) => a -> ((?self :: a) => ActionActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> action #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterActionActivate :: (IsAction a, MonadIO m) => a -> ((?self :: a) => ActionActivateCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>action-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> action #actionGroup
--   </pre>
getActionActionGroup :: (MonadIO m, IsAction o) => o -> m (Maybe ActionGroup)

-- | Set the value of the “<tt>action-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> action [ #actionGroup <a>:=</a> value ]
--   </pre>
setActionActionGroup :: (MonadIO m, IsAction o, IsActionGroup a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>action-group</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructActionActionGroup :: (IsAction o, MonadIO m, IsActionGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>action-group</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #actionGroup
--   </pre>
clearActionActionGroup :: (MonadIO m, IsAction o) => o -> m ()

-- | Get the value of the “<tt>always-show-image</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> action #alwaysShowImage
--   </pre>
getActionAlwaysShowImage :: (MonadIO m, IsAction o) => o -> m Bool

-- | Set the value of the “<tt>always-show-image</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> action [ #alwaysShowImage <a>:=</a> value ]
--   </pre>
setActionAlwaysShowImage :: (MonadIO m, IsAction o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>always-show-image</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructActionAlwaysShowImage :: (IsAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> action #gicon
--   </pre>
getActionGicon :: (MonadIO m, IsAction o) => o -> m Icon

-- | Set the value of the “<tt>gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> action [ #gicon <a>:=</a> value ]
--   </pre>
setActionGicon :: (MonadIO m, IsAction o, IsIcon a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gicon</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructActionGicon :: (IsAction o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>hide-if-empty</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> action #hideIfEmpty
--   </pre>
getActionHideIfEmpty :: (MonadIO m, IsAction o) => o -> m Bool

-- | Set the value of the “<tt>hide-if-empty</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> action [ #hideIfEmpty <a>:=</a> value ]
--   </pre>
setActionHideIfEmpty :: (MonadIO m, IsAction o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hide-if-empty</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructActionHideIfEmpty :: (IsAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> action #iconName
--   </pre>
getActionIconName :: (MonadIO m, IsAction o) => o -> m Text

-- | Set the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> action [ #iconName <a>:=</a> value ]
--   </pre>
setActionIconName :: (MonadIO m, IsAction o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructActionIconName :: (IsAction o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>is-important</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> action #isImportant
--   </pre>
getActionIsImportant :: (MonadIO m, IsAction o) => o -> m Bool

-- | Set the value of the “<tt>is-important</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> action [ #isImportant <a>:=</a> value ]
--   </pre>
setActionIsImportant :: (MonadIO m, IsAction o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>is-important</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructActionIsImportant :: (IsAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> action #label
--   </pre>
getActionLabel :: (MonadIO m, IsAction o) => o -> m Text

-- | Set the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> action [ #label <a>:=</a> value ]
--   </pre>
setActionLabel :: (MonadIO m, IsAction o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructActionLabel :: (IsAction o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> action #name
--   </pre>
getActionName :: (MonadIO m, IsAction o) => o -> m Text

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>name</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructActionName :: (IsAction o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> action #sensitive
--   </pre>
getActionSensitive :: (MonadIO m, IsAction o) => o -> m Bool

-- | Set the value of the “<tt>sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> action [ #sensitive <a>:=</a> value ]
--   </pre>
setActionSensitive :: (MonadIO m, IsAction o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sensitive</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructActionSensitive :: (IsAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>short-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> action #shortLabel
--   </pre>
getActionShortLabel :: (MonadIO m, IsAction o) => o -> m Text

-- | Set the value of the “<tt>short-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> action [ #shortLabel <a>:=</a> value ]
--   </pre>
setActionShortLabel :: (MonadIO m, IsAction o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>short-label</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructActionShortLabel :: (IsAction o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>stock-id</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> action #stockId
--   </pre>
getActionStockId :: (MonadIO m, IsAction o) => o -> m Text

-- | Set the value of the “<tt>stock-id</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> action [ #stockId <a>:=</a> value ]
--   </pre>
setActionStockId :: (MonadIO m, IsAction o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stock-id</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructActionStockId :: (IsAction o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>tooltip</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> action #tooltip
--   </pre>
getActionTooltip :: (MonadIO m, IsAction o) => o -> m Text

-- | Set the value of the “<tt>tooltip</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> action [ #tooltip <a>:=</a> value ]
--   </pre>
setActionTooltip :: (MonadIO m, IsAction o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructActionTooltip :: (IsAction o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> action #visible
--   </pre>
getActionVisible :: (MonadIO m, IsAction o) => o -> m Bool

-- | Set the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> action [ #visible <a>:=</a> value ]
--   </pre>
setActionVisible :: (MonadIO m, IsAction o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructActionVisible :: (IsAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible-horizontal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> action #visibleHorizontal
--   </pre>
getActionVisibleHorizontal :: (MonadIO m, IsAction o) => o -> m Bool

-- | Set the value of the “<tt>visible-horizontal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> action [ #visibleHorizontal <a>:=</a> value ]
--   </pre>
setActionVisibleHorizontal :: (MonadIO m, IsAction o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible-horizontal</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructActionVisibleHorizontal :: (IsAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible-overflown</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> action #visibleOverflown
--   </pre>
getActionVisibleOverflown :: (MonadIO m, IsAction o) => o -> m Bool

-- | Set the value of the “<tt>visible-overflown</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> action [ #visibleOverflown <a>:=</a> value ]
--   </pre>
setActionVisibleOverflown :: (MonadIO m, IsAction o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible-overflown</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructActionVisibleOverflown :: (IsAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible-vertical</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> action #visibleVertical
--   </pre>
getActionVisibleVertical :: (MonadIO m, IsAction o) => o -> m Bool

-- | Set the value of the “<tt>visible-vertical</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> action [ #visibleVertical <a>:=</a> value ]
--   </pre>
setActionVisibleVertical :: (MonadIO m, IsAction o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible-vertical</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructActionVisibleVertical :: (IsAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>Action</a> object. To add the action to a
--   <a>ActionGroup</a> and set the accelerator for the action, call
--   <a>actionGroupAddActionWithAccel</a>. See the [UI Definition
--   section][XML-UI] for information on allowed action names.
--   
--   <i>Since: 2.4</i>
actionNew :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Maybe Text -> m Action

-- | Emits the “activate” signal on the specified action, if it isn't
--   insensitive. This gets called by the proxy widgets when they get
--   activated.
--   
--   It can also be used to manually activate an action.
--   
--   <i>Since: 2.4</i>
actionActivate :: (HasCallStack, MonadIO m, IsAction a) => a -> m ()

-- | Disable activation signals from the action
--   
--   This is needed when updating the state of your proxy
--   <a>Activatable</a> widget could result in calling
--   <a>actionActivate</a>, this is a convenience function to avoid
--   recursing in those cases (updating toggle state for instance).
--   
--   <i>Since: 2.16</i>
actionBlockActivate :: (HasCallStack, MonadIO m, IsAction a) => a -> m ()

-- | Installs the accelerator for <i><tt>action</tt></i> if
--   <i><tt>action</tt></i> has an accel path and group. See
--   <a>actionSetAccelPath</a> and <a>actionSetAccelGroup</a>
--   
--   Since multiple proxies may independently trigger the installation of
--   the accelerator, the <i><tt>action</tt></i> counts the number of times
--   this function has been called and doesn’t remove the accelerator until
--   <a>actionDisconnectAccelerator</a> has been called as many times.
--   
--   <i>Since: 2.4</i>
actionConnectAccelerator :: (HasCallStack, MonadIO m, IsAction a) => a -> m ()

-- | This function is intended for use by action implementations to create
--   icons displayed in the proxy widgets.
--   
--   <i>Since: 2.4</i>
actionCreateIcon :: (HasCallStack, MonadIO m, IsAction a) => a -> Int32 -> m Widget

-- | If <i><tt>action</tt></i> provides a <a>Menu</a> widget as a submenu
--   for the menu item or the toolbar item it creates, this function
--   returns an instance of that menu.
--   
--   <i>Since: 2.12</i>
actionCreateMenu :: (HasCallStack, MonadIO m, IsAction a) => a -> m Widget

-- | Creates a menu item widget that proxies for the given action.
--   
--   <i>Since: 2.4</i>
actionCreateMenuItem :: (HasCallStack, MonadIO m, IsAction a) => a -> m Widget

-- | Creates a toolbar item widget that proxies for the given action.
--   
--   <i>Since: 2.4</i>
actionCreateToolItem :: (HasCallStack, MonadIO m, IsAction a) => a -> m Widget

-- | Undoes the effect of one call to <a>actionConnectAccelerator</a>.
--   
--   <i>Since: 2.4</i>
actionDisconnectAccelerator :: (HasCallStack, MonadIO m, IsAction a) => a -> m ()

-- | Returns the accel closure for this action.
--   
--   <i>Since: 2.8</i>
actionGetAccelClosure :: (HasCallStack, MonadIO m, IsAction a) => a -> m (GClosure b)

-- | Returns the accel path for this action.
--   
--   <i>Since: 2.6</i>
actionGetAccelPath :: (HasCallStack, MonadIO m, IsAction a) => a -> m Text

-- | Returns whether <i><tt>action</tt></i>'s menu item proxies will always
--   show their image, if available.
--   
--   <i>Since: 2.20</i>
actionGetAlwaysShowImage :: (HasCallStack, MonadIO m, IsAction a) => a -> m Bool

-- | Gets the gicon of <i><tt>action</tt></i>.
--   
--   <i>Since: 2.16</i>
actionGetGicon :: (HasCallStack, MonadIO m, IsAction a) => a -> m Icon

-- | Gets the icon name of <i><tt>action</tt></i>.
--   
--   <i>Since: 2.16</i>
actionGetIconName :: (HasCallStack, MonadIO m, IsAction a) => a -> m Text

-- | Checks whether <i><tt>action</tt></i> is important or not
--   
--   <i>Since: 2.16</i>
actionGetIsImportant :: (HasCallStack, MonadIO m, IsAction a) => a -> m Bool

-- | Gets the label text of <i><tt>action</tt></i>.
--   
--   <i>Since: 2.16</i>
actionGetLabel :: (HasCallStack, MonadIO m, IsAction a) => a -> m Text

-- | Returns the name of the action.
--   
--   <i>Since: 2.4</i>
actionGetName :: (HasCallStack, MonadIO m, IsAction a) => a -> m Text

-- | Returns the proxy widgets for an action. See also
--   <a>activatableGetRelatedAction</a>.
--   
--   <i>Since: 2.4</i>
actionGetProxies :: (HasCallStack, MonadIO m, IsAction a) => a -> m [Widget]

-- | Gets the short label text of <i><tt>action</tt></i>.
--   
--   <i>Since: 2.16</i>
actionGetShortLabel :: (HasCallStack, MonadIO m, IsAction a) => a -> m Text

-- | Gets the stock id of <i><tt>action</tt></i>.
--   
--   <i>Since: 2.16</i>
actionGetStockId :: (HasCallStack, MonadIO m, IsAction a) => a -> m Text

-- | Gets the tooltip text of <i><tt>action</tt></i>.
--   
--   <i>Since: 2.16</i>
actionGetTooltip :: (HasCallStack, MonadIO m, IsAction a) => a -> m Text

-- | Checks whether <i><tt>action</tt></i> is visible when horizontal
--   
--   <i>Since: 2.16</i>
actionGetVisibleHorizontal :: (HasCallStack, MonadIO m, IsAction a) => a -> m Bool

-- | Checks whether <i><tt>action</tt></i> is visible when horizontal
--   
--   <i>Since: 2.16</i>
actionGetVisibleVertical :: (HasCallStack, MonadIO m, IsAction a) => a -> m Bool

-- | Sets the <a>AccelGroup</a> in which the accelerator for this action
--   will be installed.
--   
--   <i>Since: 2.4</i>
actionSetAccelGroup :: (HasCallStack, MonadIO m, IsAction a, IsAccelGroup b) => a -> Maybe b -> m ()

-- | Sets whether <i><tt>action</tt></i>'s menu item proxies will ignore
--   the <a>Settings:gtkMenuImages</a> setting and always show their image,
--   if available.
--   
--   Use this if the menu item would be useless or hard to use without
--   their image.
--   
--   <i>Since: 2.20</i>
actionSetAlwaysShowImage :: (HasCallStack, MonadIO m, IsAction a) => a -> Bool -> m ()

-- | Sets the icon of <i><tt>action</tt></i>.
--   
--   <i>Since: 2.16</i>
actionSetGicon :: (HasCallStack, MonadIO m, IsAction a, IsIcon b) => a -> b -> m ()

-- | Sets the icon name on <i><tt>action</tt></i>
--   
--   <i>Since: 2.16</i>
actionSetIconName :: (HasCallStack, MonadIO m, IsAction a) => a -> Text -> m ()

-- | Sets whether the action is important, this attribute is used primarily
--   by toolbar items to decide whether to show a label or not.
--   
--   <i>Since: 2.16</i>
actionSetIsImportant :: (HasCallStack, MonadIO m, IsAction a) => a -> Bool -> m ()

-- | Sets the label of <i><tt>action</tt></i>.
--   
--   <i>Since: 2.16</i>
actionSetLabel :: (HasCallStack, MonadIO m, IsAction a) => a -> Text -> m ()

-- | Sets the :sensitive property of the action to
--   <i><tt>sensitive</tt></i>. Note that this doesn’t necessarily mean
--   effective sensitivity. See <a>actionIsSensitive</a> for that.
--   
--   <i>Since: 2.6</i>
actionSetSensitive :: (HasCallStack, MonadIO m, IsAction a) => a -> Bool -> m ()

-- | Sets a shorter label text on <i><tt>action</tt></i>.
--   
--   <i>Since: 2.16</i>
actionSetShortLabel :: (HasCallStack, MonadIO m, IsAction a) => a -> Text -> m ()

-- | Sets the stock id on <i><tt>action</tt></i>
--   
--   <i>Since: 2.16</i>
actionSetStockId :: (HasCallStack, MonadIO m, IsAction a) => a -> Text -> m ()

-- | Sets the tooltip text on <i><tt>action</tt></i>
--   
--   <i>Since: 2.16</i>
actionSetTooltip :: (HasCallStack, MonadIO m, IsAction a) => a -> Text -> m ()

-- | Sets the :visible property of the action to <i><tt>visible</tt></i>.
--   Note that this doesn’t necessarily mean effective visibility. See
--   <a>actionIsVisible</a> for that.
--   
--   <i>Since: 2.6</i>
actionSetVisible :: (HasCallStack, MonadIO m, IsAction a) => a -> Bool -> m ()

-- | Sets whether <i><tt>action</tt></i> is visible when horizontal
--   
--   <i>Since: 2.16</i>
actionSetVisibleHorizontal :: (HasCallStack, MonadIO m, IsAction a) => a -> Bool -> m ()

-- | Sets whether <i><tt>action</tt></i> is visible when vertical
--   
--   <i>Since: 2.16</i>
actionSetVisibleVertical :: (HasCallStack, MonadIO m, IsAction a) => a -> Bool -> m ()

-- | Reenable activation signals from the action
--   
--   <i>Since: 2.16</i>
actionUnblockActivate :: (HasCallStack, MonadIO m, IsAction a) => a -> m ()

-- | Get the value of the “<tt>related-action</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> activatable #relatedAction
--   </pre>
getActivatableRelatedAction :: (MonadIO m, IsActivatable o) => o -> m Action

-- | Set the value of the “<tt>related-action</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> activatable [ #relatedAction <a>:=</a> value ]
--   </pre>
setActivatableRelatedAction :: (MonadIO m, IsActivatable o, IsAction a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>related-action</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructActivatableRelatedAction :: (IsActivatable o, MonadIO m, IsAction a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-action-appearance</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> activatable #useActionAppearance
--   </pre>
getActivatableUseActionAppearance :: (MonadIO m, IsActivatable o) => o -> m Bool

-- | Set the value of the “<tt>use-action-appearance</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> activatable [ #useActionAppearance <a>:=</a> value ]
--   </pre>
setActivatableUseActionAppearance :: (MonadIO m, IsActivatable o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-action-appearance</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructActivatableUseActionAppearance :: (IsActivatable o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | This is a utility function for <a>Activatable</a> implementors.
--   
--   When implementing <a>Activatable</a> you must call this when handling
--   changes of the <a>Activatable</a>:<tt><i>related-action</i></tt>, and
--   you must also use this to break references in
--   <a>Object</a>-&gt;<tt><i>dispose()</i></tt>.
--   
--   This function adds a reference to the currently set related action for
--   you, it also makes sure the
--   <a>Activatable</a>-&gt;<tt><i>update()</i></tt> method is called when
--   the related <a>Action</a> properties change and registers to the
--   action’s proxy list.
--   
--   <pre>
--   Be careful to call this before setting the local
--   copy of the t'GI.Gtk.Objects.Action.Action' property, since this function uses
--   'GI.Gtk.Interfaces.Activatable.activatableGetRelatedAction' to retrieve the
--   previous action.
--   </pre>
--   
--   <i>Since: 2.16</i>
activatableDoSetRelatedAction :: (HasCallStack, MonadIO m, IsActivatable a, IsAction b) => a -> b -> m ()

-- | Gets whether this activatable should reset its layout and appearance
--   when setting the related action or when the action changes appearance.
--   
--   <i>Since: 2.16</i>
activatableGetUseActionAppearance :: (HasCallStack, MonadIO m, IsActivatable a) => a -> m Bool

-- | Sets the related action on the <i><tt>activatable</tt></i> object.
--   
--   <pre>
--   t'GI.Gtk.Interfaces.Activatable.Activatable' implementors need to handle the t'GI.Gtk.Interfaces.Activatable.Activatable':@/related-action/@
--   property and call 'GI.Gtk.Interfaces.Activatable.activatableDoSetRelatedAction' when it changes.
--   </pre>
--   
--   <i>Since: 2.16</i>
activatableSetRelatedAction :: (HasCallStack, MonadIO m, IsActivatable a, IsAction b) => a -> b -> m ()

-- | Sets whether this activatable should reset its layout and appearance
--   when setting the related action or when the action changes appearance
--   
--   <pre>
--   t'GI.Gtk.Interfaces.Activatable.Activatable' implementors need to handle the
--   t'GI.Gtk.Interfaces.Activatable.Activatable':@/use-action-appearance/@ property and call
--   'GI.Gtk.Interfaces.Activatable.activatableSyncActionProperties' to update /@activatable@/
--   if needed.
--   </pre>
--   
--   <i>Since: 2.16</i>
activatableSetUseActionAppearance :: (HasCallStack, MonadIO m, IsActivatable a) => a -> Bool -> m ()

-- | This is called to update the activatable completely, this is called
--   internally when the <a>Activatable</a>:<tt><i>related-action</i></tt>
--   property is set or unset and by the implementing class when
--   <a>Activatable</a>:<tt><i>use-action-appearance</i></tt> changes.
--   
--   <i>Since: 2.16</i>
activatableSyncActionProperties :: (HasCallStack, MonadIO m, IsActivatable a, IsAction b) => a -> Maybe b -> m ()

-- | Get the value of the “<tt>action-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionable #actionName
--   </pre>
getActionableActionName :: (MonadIO m, IsActionable o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>action-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionable [ #actionName <a>:=</a> value ]
--   </pre>
setActionableActionName :: (MonadIO m, IsActionable o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>action-name</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructActionableActionName :: (IsActionable o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>action-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #actionName
--   </pre>
clearActionableActionName :: (MonadIO m, IsActionable o) => o -> m ()

-- | Get the value of the “<tt>action-target</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionable #actionTarget
--   </pre>
getActionableActionTarget :: (MonadIO m, IsActionable o) => o -> m (Maybe GVariant)

-- | Set the value of the “<tt>action-target</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionable [ #actionTarget <a>:=</a> value ]
--   </pre>
setActionableActionTarget :: (MonadIO m, IsActionable o) => o -> GVariant -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>action-target</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructActionableActionTarget :: (IsActionable o, MonadIO m) => GVariant -> m (GValueConstruct o)

-- | Set the value of the “<tt>action-target</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #actionTarget
--   </pre>
clearActionableActionTarget :: (MonadIO m, IsActionable o) => o -> m ()

-- | Gets the action name for <i><tt>actionable</tt></i>.
--   
--   See <a>actionableSetActionName</a> for more information.
--   
--   <i>Since: 3.4</i>
actionableGetActionName :: (HasCallStack, MonadIO m, IsActionable a) => a -> m (Maybe Text)

-- | Gets the current target value of <i><tt>actionable</tt></i>.
--   
--   See <a>actionableSetActionTargetValue</a> for more information.
--   
--   <i>Since: 3.4</i>
actionableGetActionTargetValue :: (HasCallStack, MonadIO m, IsActionable a) => a -> m GVariant

-- | Specifies the name of the action with which this widget should be
--   associated. If <i><tt>actionName</tt></i> is <a>Nothing</a> then the
--   widget will be unassociated from any previous action.
--   
--   Usually this function is used when the widget is located (or will be
--   located) within the hierarchy of a <a>ApplicationWindow</a>.
--   
--   Names are of the form “win.save” or “app.quit” for actions on the
--   containing <a>ApplicationWindow</a> or its associated
--   <a>Application</a>, respectively. This is the same form used for
--   actions in the <a>Menu</a> associated with the window.
--   
--   <i>Since: 3.4</i>
actionableSetActionName :: (HasCallStack, MonadIO m, IsActionable a) => a -> Maybe Text -> m ()

-- | Sets the target value of an actionable widget.
--   
--   If <i><tt>targetValue</tt></i> is <a>Nothing</a> then the target value
--   is unset.
--   
--   The target value has two purposes. First, it is used as the parameter
--   to activation of the action associated with the <a>Actionable</a>
--   widget. Second, it is used to determine if the widget should be
--   rendered as “active” — the widget is active if the state is equal to
--   the given target.
--   
--   Consider the example of associating a set of buttons with a
--   <a>Action</a> with string state in a typical “radio button” situation.
--   Each button will be associated with the same action, but with a
--   different target value for that action. Clicking on a particular
--   button will activate the action with the target of that button, which
--   will typically cause the action’s state to change to that value. Since
--   the action’s state is now equal to the target value of the button, the
--   button will now be rendered as active (and the other buttons, with
--   different targets, rendered inactive).
--   
--   <i>Since: 3.4</i>
actionableSetActionTargetValue :: (HasCallStack, MonadIO m, IsActionable a) => a -> Maybe GVariant -> m ()

-- | Sets the action-name and associated string target value of an
--   actionable widget.
--   
--   <i><tt>detailedActionName</tt></i> is a string in the format accepted
--   by <a>actionParseDetailedName</a>.
--   
--   (Note that prior to version 3.22.25, this function is only usable for
--   actions with a simple "s" target, and
--   <i><tt>detailedActionName</tt></i> must be of the form
--   <tt>"action::target"</tt> where <tt>action</tt> is the action name and
--   <tt>target</tt> is the string to use as the target.)
--   
--   <i>Since: 3.4</i>
actionableSetDetailedActionName :: (HasCallStack, MonadIO m, IsActionable a) => a -> Text -> m ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> listBoxRow #activate callback
--   </pre>
onListBoxRowActivate :: (IsListBoxRow a, MonadIO m) => a -> ((?self :: a) => ListBoxRowActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> listBoxRow #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxRowActivate :: (IsListBoxRow a, MonadIO m) => a -> ((?self :: a) => ListBoxRowActivateCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>activatable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listBoxRow #activatable
--   </pre>
getListBoxRowActivatable :: (MonadIO m, IsListBoxRow o) => o -> m Bool

-- | Set the value of the “<tt>activatable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listBoxRow [ #activatable <a>:=</a> value ]
--   </pre>
setListBoxRowActivatable :: (MonadIO m, IsListBoxRow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activatable</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructListBoxRowActivatable :: (IsListBoxRow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>selectable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listBoxRow #selectable
--   </pre>
getListBoxRowSelectable :: (MonadIO m, IsListBoxRow o) => o -> m Bool

-- | Set the value of the “<tt>selectable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listBoxRow [ #selectable <a>:=</a> value ]
--   </pre>
setListBoxRowSelectable :: (MonadIO m, IsListBoxRow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>selectable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructListBoxRowSelectable :: (IsListBoxRow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>ListBoxRow</a>, to be used as a child of a
--   <a>ListBox</a>.
--   
--   <i>Since: 3.10</i>
listBoxRowNew :: (HasCallStack, MonadIO m) => m ListBoxRow

-- | Gets the value of the <a>ListBoxRow:activatable</a> property for this
--   row.
--   
--   <i>Since: 3.14</i>
listBoxRowGetActivatable :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m Bool

-- | Gets the current index of the <i><tt>row</tt></i> in its
--   <a>ListBox</a> container.
--   
--   <i>Since: 3.10</i>
listBoxRowGetIndex :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m Int32

-- | Gets the value of the <a>ListBoxRow:selectable</a> property for this
--   row.
--   
--   <i>Since: 3.14</i>
listBoxRowGetSelectable :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m Bool

-- | Returns whether the child is currently selected in its <a>ListBox</a>
--   container.
--   
--   <i>Since: 3.14</i>
listBoxRowIsSelected :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m Bool

-- | Set the <a>ListBoxRow:activatable</a> property for this row.
--   
--   <i>Since: 3.14</i>
listBoxRowSetActivatable :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> Bool -> m ()

-- | Set the <a>ListBoxRow:selectable</a> property for this row.
--   
--   <i>Since: 3.14</i>
listBoxRowSetSelectable :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> Bool -> m ()

-- | Connect a signal handler for the <a>activateCursorRow</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> listBox #activateCursorRow callback
--   </pre>
onListBoxActivateCursorRow :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxActivateCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateCursorRow</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> listBox #activateCursorRow callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxActivateCursorRow :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxActivateCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> listBox #moveCursor callback
--   </pre>
onListBoxMoveCursor :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> listBox #moveCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxMoveCursor :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowActivated</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> listBox #rowActivated callback
--   </pre>
onListBoxRowActivated :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxRowActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowActivated</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> listBox #rowActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxRowActivated :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxRowActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowSelected</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> listBox #rowSelected callback
--   </pre>
onListBoxRowSelected :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxRowSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowSelected</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> listBox #rowSelected callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxRowSelected :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxRowSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> listBox #selectAll callback
--   </pre>
onListBoxSelectAll :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> listBox #selectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxSelectAll :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectedRowsChanged</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> listBox #selectedRowsChanged callback
--   </pre>
onListBoxSelectedRowsChanged :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxSelectedRowsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectedRowsChanged</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> listBox #selectedRowsChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxSelectedRowsChanged :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxSelectedRowsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleCursorRow</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> listBox #toggleCursorRow callback
--   </pre>
onListBoxToggleCursorRow :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxToggleCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleCursorRow</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> listBox #toggleCursorRow callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxToggleCursorRow :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxToggleCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unselectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> listBox #unselectAll callback
--   </pre>
onListBoxUnselectAll :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxUnselectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unselectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> listBox #unselectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxUnselectAll :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxUnselectAllCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>activate-on-single-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listBox #activateOnSingleClick
--   </pre>
getListBoxActivateOnSingleClick :: (MonadIO m, IsListBox o) => o -> m Bool

-- | Set the value of the “<tt>activate-on-single-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listBox [ #activateOnSingleClick <a>:=</a> value ]
--   </pre>
setListBoxActivateOnSingleClick :: (MonadIO m, IsListBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activate-on-single-click</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructListBoxActivateOnSingleClick :: (IsListBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>selection-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listBox #selectionMode
--   </pre>
getListBoxSelectionMode :: (MonadIO m, IsListBox o) => o -> m SelectionMode

-- | Set the value of the “<tt>selection-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listBox [ #selectionMode <a>:=</a> value ]
--   </pre>
setListBoxSelectionMode :: (MonadIO m, IsListBox o) => o -> SelectionMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>selection-mode</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructListBoxSelectionMode :: (IsListBox o, MonadIO m) => SelectionMode -> m (GValueConstruct o)

-- | Creates a new <a>ListBox</a> container.
--   
--   <i>Since: 3.10</i>
listBoxNew :: (HasCallStack, MonadIO m) => m ListBox

-- | This is a helper function for implementing DnD onto a <a>ListBox</a>.
--   The passed in <i><tt>row</tt></i> will be highlighted via
--   <a>widgetDragHighlight</a>, and any previously highlighted row will be
--   unhighlighted.
--   
--   The row will also be unhighlighted when the widget gets a drag leave
--   event.
--   
--   <i>Since: 3.10</i>
listBoxDragHighlightRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> b -> m ()

-- | If a row has previously been highlighted via
--   <a>listBoxDragHighlightRow</a> it will have the highlight removed.
--   
--   <i>Since: 3.10</i>
listBoxDragUnhighlightRow :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Returns whether rows activate on single clicks.
--   
--   <i>Since: 3.10</i>
listBoxGetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsListBox a) => a -> m Bool

-- | Gets the adjustment (if any) that the widget uses to for vertical
--   scrolling.
--   
--   <i>Since: 3.10</i>
listBoxGetAdjustment :: (HasCallStack, MonadIO m, IsListBox a) => a -> m Adjustment

-- | Gets the n-th child in the list (not counting headers). If
--   <i><tt>index_</tt></i> is negative or larger than the number of items
--   in the list, <a>Nothing</a> is returned.
--   
--   <i>Since: 3.10</i>
listBoxGetRowAtIndex :: (HasCallStack, MonadIO m, IsListBox a) => a -> Int32 -> m (Maybe ListBoxRow)

-- | Gets the row at the <i><tt>y</tt></i> position.
--   
--   <i>Since: 3.10</i>
listBoxGetRowAtY :: (HasCallStack, MonadIO m, IsListBox a) => a -> Int32 -> m (Maybe ListBoxRow)

-- | Gets the selected row.
--   
--   Note that the box may allow multiple selection, in which case you
--   should use <a>listBoxSelectedForeach</a> to find all selected rows.
--   
--   <i>Since: 3.10</i>
listBoxGetSelectedRow :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ListBoxRow

-- | Creates a list of all selected children.
--   
--   <i>Since: 3.14</i>
listBoxGetSelectedRows :: (HasCallStack, MonadIO m, IsListBox a) => a -> m [ListBoxRow]

-- | Gets the selection mode of the listbox.
--   
--   <i>Since: 3.10</i>
listBoxGetSelectionMode :: (HasCallStack, MonadIO m, IsListBox a) => a -> m SelectionMode

-- | Insert the <i><tt>child</tt></i> into the <i><tt>box</tt></i> at
--   <i><tt>position</tt></i>. If a sort function is set, the widget will
--   actually be inserted at the calculated position and this function has
--   the same effect of <a>containerAdd</a>.
--   
--   If <i><tt>position</tt></i> is -1, or larger than the total number of
--   items in the <i><tt>box</tt></i>, then the <i><tt>child</tt></i> will
--   be appended to the end.
--   
--   <i>Since: 3.10</i>
listBoxInsert :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Update the filtering for all rows. Call this when result of the filter
--   function on the <i><tt>box</tt></i> is changed due to an external
--   factor. For instance, this would be used if the filter function just
--   looked for a specific search string and the entry with the search
--   string has changed.
--   
--   <i>Since: 3.10</i>
listBoxInvalidateFilter :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Update the separators for all rows. Call this when result of the
--   header function on the <i><tt>box</tt></i> is changed due to an
--   external factor.
--   
--   <i>Since: 3.10</i>
listBoxInvalidateHeaders :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Prepend a widget to the list. If a sort function is set, the widget
--   will actually be inserted at the calculated position and this function
--   has the same effect of <a>containerAdd</a>.
--   
--   <i>Since: 3.10</i>
listBoxPrepend :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> b -> m ()

-- | Select all children of <i><tt>box</tt></i>, if the selection mode
--   allows it.
--   
--   <i>Since: 3.14</i>
listBoxSelectAll :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Make <i><tt>row</tt></i> the currently selected row.
--   
--   <i>Since: 3.10</i>
listBoxSelectRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> Maybe b -> m ()

-- | If <i><tt>single</tt></i> is <a>True</a>, rows will be activated when
--   you click on them, otherwise you need to double-click.
--   
--   <i>Since: 3.10</i>
listBoxSetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsListBox a) => a -> Bool -> m ()

-- | Sets the adjustment (if any) that the widget uses to for vertical
--   scrolling. For instance, this is used to get the page size for
--   PageUp/Down key handling.
--   
--   In the normal case when the <i><tt>box</tt></i> is packed inside a
--   <a>ScrolledWindow</a> the adjustment from that will be picked up
--   automatically, so there is no need to manually do that.
--   
--   <i>Since: 3.10</i>
listBoxSetAdjustment :: (HasCallStack, MonadIO m, IsListBox a, IsAdjustment b) => a -> Maybe b -> m ()

-- | By setting a filter function on the <i><tt>box</tt></i> one can decide
--   dynamically which of the rows to show. For instance, to implement a
--   search function on a list that filters the original list to only show
--   the matching rows.
--   
--   The <i><tt>filterFunc</tt></i> will be called for each row after the
--   call, and it will continue to be called each time a row changes (via
--   <a>listBoxRowChanged</a>) or when <a>listBoxInvalidateFilter</a> is
--   called.
--   
--   Note that using a filter function is incompatible with using a model
--   (see <a>listBoxBindModel</a>).
--   
--   <i>Since: 3.10</i>
listBoxSetFilterFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxFilterFunc -> m ()

-- | By setting a header function on the <i><tt>box</tt></i> one can
--   dynamically add headers in front of rows, depending on the contents of
--   the row and its position in the list. For instance, one could use it
--   to add headers in front of the first item of a new kind, in a list
--   sorted by the kind.
--   
--   The <i><tt>updateHeader</tt></i> can look at the current header widget
--   using <a>listBoxRowGetHeader</a> and either update the state of the
--   widget as needed, or set a new one using <a>listBoxRowSetHeader</a>.
--   If no header is needed, set the header to <a>Nothing</a>.
--   
--   Note that you may get many calls <i><tt>updateHeader</tt></i> to this
--   for a particular row when e.g. changing things that don’t affect the
--   header. In this case it is important for performance to not blindly
--   replace an existing header with an identical one.
--   
--   The <i><tt>updateHeader</tt></i> function will be called for each row
--   after the call, and it will continue to be called each time a row
--   changes (via <a>listBoxRowChanged</a>) and when the row before changes
--   (either by <a>listBoxRowChanged</a> on the previous row, or when the
--   previous row becomes a different row). It is also called for all rows
--   when <a>listBoxInvalidateHeaders</a> is called.
--   
--   <i>Since: 3.10</i>
listBoxSetHeaderFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxUpdateHeaderFunc -> m ()

-- | Sets the placeholder widget that is shown in the list when it doesn't
--   display any visible children.
--   
--   <i>Since: 3.10</i>
listBoxSetPlaceholder :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets how selection works in the listbox. See <a>SelectionMode</a> for
--   details.
--   
--   <i>Since: 3.10</i>
listBoxSetSelectionMode :: (HasCallStack, MonadIO m, IsListBox a) => a -> SelectionMode -> m ()

-- | By setting a sort function on the <i><tt>box</tt></i> one can
--   dynamically reorder the rows of the list, based on the contents of the
--   rows.
--   
--   The <i><tt>sortFunc</tt></i> will be called for each row after the
--   call, and will continue to be called each time a row changes (via
--   <a>listBoxRowChanged</a>) and when <a>listBoxInvalidateSort</a> is
--   called.
--   
--   Note that using a sort function is incompatible with using a model
--   (see <a>listBoxBindModel</a>).
--   
--   <i>Since: 3.10</i>
listBoxSetSortFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxSortFunc -> m ()

-- | Unselect all children of <i><tt>box</tt></i>, if the selection mode
--   allows it.
--   
--   <i>Since: 3.14</i>
listBoxUnselectAll :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Unselects a single row of <i><tt>box</tt></i>, if the selection mode
--   allows it.
--   
--   <i>Since: 3.14</i>
listBoxUnselectRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> b -> m ()

-- | Connect a signal handler for the <a>activateCursorItem</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iconView #activateCursorItem callback
--   </pre>
onIconViewActivateCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewActivateCursorItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateCursorItem</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iconView #activateCursorItem callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconViewActivateCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewActivateCursorItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>itemActivated</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iconView #itemActivated callback
--   </pre>
onIconViewItemActivated :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewItemActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>itemActivated</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iconView #itemActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconViewItemActivated :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewItemActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> iconView #moveCursor callback
--   </pre>
onIconViewMoveCursor :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> iconView #moveCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconViewMoveCursor :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> iconView #selectAll callback
--   </pre>
onIconViewSelectAll :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> iconView #selectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconViewSelectAll :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectCursorItem</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iconView #selectCursorItem callback
--   </pre>
onIconViewSelectCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectCursorItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectCursorItem</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iconView #selectCursorItem callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconViewSelectCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectCursorItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iconView #selectionChanged callback
--   </pre>
onIconViewSelectionChanged :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iconView #selectionChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconViewSelectionChanged :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleCursorItem</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iconView #toggleCursorItem callback
--   </pre>
onIconViewToggleCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewToggleCursorItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleCursorItem</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iconView #toggleCursorItem callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconViewToggleCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewToggleCursorItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unselectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> iconView #unselectAll callback
--   </pre>
onIconViewUnselectAll :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewUnselectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unselectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> iconView #unselectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconViewUnselectAll :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewUnselectAllCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>activate-on-single-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #activateOnSingleClick
--   </pre>
getIconViewActivateOnSingleClick :: (MonadIO m, IsIconView o) => o -> m Bool

-- | Set the value of the “<tt>activate-on-single-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #activateOnSingleClick <a>:=</a> value ]
--   </pre>
setIconViewActivateOnSingleClick :: (MonadIO m, IsIconView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activate-on-single-click</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructIconViewActivateOnSingleClick :: (IsIconView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>cell-area</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #cellArea
--   </pre>
getIconViewCellArea :: (MonadIO m, IsIconView o) => o -> m (Maybe CellArea)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-area</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructIconViewCellArea :: (IsIconView o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>column-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #columnSpacing
--   </pre>
getIconViewColumnSpacing :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>column-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #columnSpacing <a>:=</a> value ]
--   </pre>
setIconViewColumnSpacing :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>column-spacing</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructIconViewColumnSpacing :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>columns</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #columns
--   </pre>
getIconViewColumns :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>columns</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #columns <a>:=</a> value ]
--   </pre>
setIconViewColumns :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>columns</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructIconViewColumns :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>item-orientation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #itemOrientation
--   </pre>
getIconViewItemOrientation :: (MonadIO m, IsIconView o) => o -> m Orientation

-- | Set the value of the “<tt>item-orientation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #itemOrientation <a>:=</a> value ]
--   </pre>
setIconViewItemOrientation :: (MonadIO m, IsIconView o) => o -> Orientation -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>item-orientation</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructIconViewItemOrientation :: (IsIconView o, MonadIO m) => Orientation -> m (GValueConstruct o)

-- | Get the value of the “<tt>item-padding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #itemPadding
--   </pre>
getIconViewItemPadding :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>item-padding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #itemPadding <a>:=</a> value ]
--   </pre>
setIconViewItemPadding :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>item-padding</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIconViewItemPadding :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>item-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #itemWidth
--   </pre>
getIconViewItemWidth :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>item-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #itemWidth <a>:=</a> value ]
--   </pre>
setIconViewItemWidth :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>item-width</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructIconViewItemWidth :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #margin
--   </pre>
getIconViewMargin :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #margin <a>:=</a> value ]
--   </pre>
setIconViewMargin :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>margin</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructIconViewMargin :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>markup-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #markupColumn
--   </pre>
getIconViewMarkupColumn :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>markup-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #markupColumn <a>:=</a> value ]
--   </pre>
setIconViewMarkupColumn :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>markup-column</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIconViewMarkupColumn :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #model
--   </pre>
getIconViewModel :: (MonadIO m, IsIconView o) => o -> m (Maybe TreeModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #model <a>:=</a> value ]
--   </pre>
setIconViewModel :: (MonadIO m, IsIconView o, IsTreeModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructIconViewModel :: (IsIconView o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearIconViewModel :: (MonadIO m, IsIconView o) => o -> m ()

-- | Get the value of the “<tt>pixbuf-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #pixbufColumn
--   </pre>
getIconViewPixbufColumn :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>pixbuf-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #pixbufColumn <a>:=</a> value ]
--   </pre>
setIconViewPixbufColumn :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixbuf-column</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIconViewPixbufColumn :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>reorderable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #reorderable
--   </pre>
getIconViewReorderable :: (MonadIO m, IsIconView o) => o -> m Bool

-- | Set the value of the “<tt>reorderable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #reorderable <a>:=</a> value ]
--   </pre>
setIconViewReorderable :: (MonadIO m, IsIconView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>reorderable</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIconViewReorderable :: (IsIconView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>row-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #rowSpacing
--   </pre>
getIconViewRowSpacing :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>row-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #rowSpacing <a>:=</a> value ]
--   </pre>
setIconViewRowSpacing :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>row-spacing</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIconViewRowSpacing :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>selection-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #selectionMode
--   </pre>
getIconViewSelectionMode :: (MonadIO m, IsIconView o) => o -> m SelectionMode

-- | Set the value of the “<tt>selection-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #selectionMode <a>:=</a> value ]
--   </pre>
setIconViewSelectionMode :: (MonadIO m, IsIconView o) => o -> SelectionMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>selection-mode</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructIconViewSelectionMode :: (IsIconView o, MonadIO m) => SelectionMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #spacing
--   </pre>
getIconViewSpacing :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #spacing <a>:=</a> value ]
--   </pre>
setIconViewSpacing :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>spacing</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructIconViewSpacing :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>text-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #textColumn
--   </pre>
getIconViewTextColumn :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>text-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #textColumn <a>:=</a> value ]
--   </pre>
setIconViewTextColumn :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-column</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIconViewTextColumn :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>tooltip-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #tooltipColumn
--   </pre>
getIconViewTooltipColumn :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>tooltip-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #tooltipColumn <a>:=</a> value ]
--   </pre>
setIconViewTooltipColumn :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip-column</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructIconViewTooltipColumn :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new <a>IconView</a> widget
--   
--   <i>Since: 2.6</i>
iconViewNew :: (HasCallStack, MonadIO m) => m IconView

-- | Creates a new <a>IconView</a> widget using the specified
--   <i><tt>area</tt></i> to layout cells inside the icons.
--   
--   <i>Since: 3.0</i>
iconViewNewWithArea :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m IconView

-- | Creates a new <a>IconView</a> widget with the model
--   <i><tt>model</tt></i>.
--   
--   <i>Since: 2.6</i>
iconViewNewWithModel :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m IconView

-- | Converts widget coordinates to coordinates for the bin_window, as
--   expected by e.g. <a>iconViewGetPathAtPos</a>.
--   
--   <i>Since: 2.12</i>
iconViewConvertWidgetToBinWindowCoords :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Creates a <a>Surface</a> representation of the item at
--   <i><tt>path</tt></i>. This image is used for a drag icon.
--   
--   <i>Since: 2.8</i>
iconViewCreateDragIcon :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m Surface

-- | Turns <i><tt>iconView</tt></i> into a drop destination for automatic
--   DND. Calling this method sets <a>IconView:reorderable</a> to
--   <a>False</a>.
--   
--   <i>Since: 2.8</i>
iconViewEnableModelDragDest :: (HasCallStack, MonadIO m, IsIconView a) => a -> [TargetEntry] -> [DragAction] -> m ()

-- | Turns <i><tt>iconView</tt></i> into a drag source for automatic DND.
--   Calling this method sets <a>IconView:reorderable</a> to <a>False</a>.
--   
--   <i>Since: 2.8</i>
iconViewEnableModelDragSource :: (HasCallStack, MonadIO m, IsIconView a) => a -> [ModifierType] -> [TargetEntry] -> [DragAction] -> m ()

-- | Gets the setting set by <a>iconViewSetActivateOnSingleClick</a>.
--   
--   <i>Since: 3.8</i>
iconViewGetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Bool

-- | Fills the bounding rectangle in widget coordinates for the cell
--   specified by <i><tt>path</tt></i> and <i><tt>cell</tt></i>. If
--   <i><tt>cell</tt></i> is <a>Nothing</a> the main cell area is used.
--   
--   This function is only valid if <i><tt>iconView</tt></i> is realized.
--   
--   <i>Since: 3.6</i>
iconViewGetCellRect :: (HasCallStack, MonadIO m, IsIconView a, IsCellRenderer b) => a -> TreePath -> Maybe b -> m (Bool, Rectangle)

-- | Returns the value of the <a>columnSpacing</a> property.
--   
--   <i>Since: 2.6</i>
iconViewGetColumnSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the value of the <a>columns</a> property.
--   
--   <i>Since: 2.6</i>
iconViewGetColumns :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Fills in <i><tt>path</tt></i> and <i><tt>cell</tt></i> with the
--   current cursor path and cell. If the cursor isn’t currently set, then
--   *<i><tt>path</tt></i> will be <a>Nothing</a>. If no cell currently has
--   focus, then *<i><tt>cell</tt></i> will be <a>Nothing</a>.
--   
--   The returned <a>TreePath</a> must be freed with <a>treePathFree</a>.
--   
--   <i>Since: 2.8</i>
iconViewGetCursor :: (HasCallStack, MonadIO m, IsIconView a) => a -> m (Bool, TreePath, CellRenderer)

-- | Determines the destination item for a given position.
--   
--   <i>Since: 2.8</i>
iconViewGetDestItemAtPos :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m (Bool, TreePath, IconViewDropPosition)

-- | Gets information about the item that is highlighted for feedback.
--   
--   <i>Since: 2.8</i>
iconViewGetDragDestItem :: (HasCallStack, MonadIO m, IsIconView a) => a -> m (TreePath, IconViewDropPosition)

-- | Finds the path at the point (<i><tt>x</tt></i>, <i><tt>y</tt></i>),
--   relative to bin_window coordinates. In contrast to
--   <a>iconViewGetPathAtPos</a>, this function also obtains the cell at
--   the specified position. The returned path should be freed with
--   <a>treePathFree</a>. See <a>iconViewConvertWidgetToBinWindowCoords</a>
--   for converting widget coordinates to bin_window coordinates.
--   
--   <i>Since: 2.8</i>
iconViewGetItemAtPos :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m (Bool, TreePath, CellRenderer)

-- | Gets the column in which the item <i><tt>path</tt></i> is currently
--   displayed. Column numbers start at 0.
--   
--   <i>Since: 2.22</i>
iconViewGetItemColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m Int32

-- | Returns the value of the <a>itemOrientation</a> property which
--   determines whether the labels are drawn beside the icons instead of
--   below.
--   
--   <i>Since: 2.6</i>
iconViewGetItemOrientation :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Orientation

-- | Returns the value of the <a>itemPadding</a> property.
--   
--   <i>Since: 2.18</i>
iconViewGetItemPadding :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Gets the row in which the item <i><tt>path</tt></i> is currently
--   displayed. Row numbers start at 0.
--   
--   <i>Since: 2.22</i>
iconViewGetItemRow :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m Int32

-- | Returns the value of the <a>itemWidth</a> property.
--   
--   <i>Since: 2.6</i>
iconViewGetItemWidth :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the value of the <a>margin</a> property.
--   
--   <i>Since: 2.6</i>
iconViewGetMargin :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the column with markup text for <i><tt>iconView</tt></i>.
--   
--   <i>Since: 2.6</i>
iconViewGetMarkupColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the model the <a>IconView</a> is based on. Returns
--   <a>Nothing</a> if the model is unset.
--   
--   <i>Since: 2.6</i>
iconViewGetModel :: (HasCallStack, MonadIO m, IsIconView a) => a -> m (Maybe TreeModel)

-- | Finds the path at the point (<i><tt>x</tt></i>, <i><tt>y</tt></i>),
--   relative to bin_window coordinates. See <a>iconViewGetItemAtPos</a>,
--   if you are also interested in the cell at the specified position. See
--   <a>iconViewConvertWidgetToBinWindowCoords</a> for converting widget
--   coordinates to bin_window coordinates.
--   
--   <i>Since: 2.6</i>
iconViewGetPathAtPos :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m (Maybe TreePath)

-- | Returns the column with pixbufs for <i><tt>iconView</tt></i>.
--   
--   <i>Since: 2.6</i>
iconViewGetPixbufColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Retrieves whether the user can reorder the list via drag-and-drop. See
--   <a>iconViewSetReorderable</a>.
--   
--   <i>Since: 2.8</i>
iconViewGetReorderable :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Bool

-- | Returns the value of the <a>rowSpacing</a> property.
--   
--   <i>Since: 2.6</i>
iconViewGetRowSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Creates a list of paths of all selected items. Additionally, if you
--   are planning on modifying the model after calling this function, you
--   may want to convert the returned list into a list of
--   <tt><i>GtkTreeRowReferences</i></tt>. To do this, you can use
--   <a>treeRowReferenceNew</a>.
--   
--   To free the return value, use:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
--   </pre>
--   
--   <i>Since: 2.6</i>
iconViewGetSelectedItems :: (HasCallStack, MonadIO m, IsIconView a) => a -> m [TreePath]

-- | Gets the selection mode of the <i><tt>iconView</tt></i>.
--   
--   <i>Since: 2.6</i>
iconViewGetSelectionMode :: (HasCallStack, MonadIO m, IsIconView a) => a -> m SelectionMode

-- | Returns the value of the <a>spacing</a> property.
--   
--   <i>Since: 2.6</i>
iconViewGetSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the column with text for <i><tt>iconView</tt></i>.
--   
--   <i>Since: 2.6</i>
iconViewGetTextColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the column of <i><tt>iconView</tt></i>’s model which is being
--   used for displaying tooltips on <i><tt>iconView</tt></i>’s rows.
--   
--   <i>Since: 2.12</i>
iconViewGetTooltipColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | This function is supposed to be used in a <a>Widget::queryTooltip</a>
--   signal handler for <a>IconView</a>. The <i><tt>x</tt></i>,
--   <i><tt>y</tt></i> and <i><tt>keyboardTip</tt></i> values which are
--   received in the signal handler, should be passed to this function
--   without modification.
--   
--   The return value indicates whether there is an icon view item at the
--   given coordinates (<a>True</a>) or not (<a>False</a>) for mouse
--   tooltips. For keyboard tooltips the item returned will be the cursor
--   item. When <a>True</a>, then any of <i><tt>model</tt></i>,
--   <i><tt>path</tt></i> and <i><tt>iter</tt></i> which have been provided
--   will be set to point to that row and the corresponding model.
--   <i><tt>x</tt></i> and <i><tt>y</tt></i> will always be converted to be
--   relative to <i><tt>iconView</tt></i>’s bin_window if
--   <i><tt>keyboardTooltip</tt></i> is <a>False</a>.
--   
--   <i>Since: 2.12</i>
iconViewGetTooltipContext :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> Bool -> m (Bool, Int32, Int32, TreeModel, TreePath, TreeIter)

-- | Sets <i><tt>startPath</tt></i> and <i><tt>endPath</tt></i> to be the
--   first and last visible path. Note that there may be invisible paths in
--   between.
--   
--   Both paths should be freed with <a>treePathFree</a> after use.
--   
--   <i>Since: 2.8</i>
iconViewGetVisibleRange :: (HasCallStack, MonadIO m, IsIconView a) => a -> m (Bool, TreePath, TreePath)

-- | Activates the item determined by <i><tt>path</tt></i>.
--   
--   <i>Since: 2.6</i>
iconViewItemActivated :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m ()

-- | Returns <a>True</a> if the icon pointed to by <i><tt>path</tt></i> is
--   currently selected. If <i><tt>path</tt></i> does not point to a valid
--   location, <a>False</a> is returned.
--   
--   <i>Since: 2.6</i>
iconViewPathIsSelected :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m Bool

-- | Moves the alignments of <i><tt>iconView</tt></i> to the position
--   specified by <i><tt>path</tt></i>. <i><tt>rowAlign</tt></i> determines
--   where the row is placed, and <i><tt>colAlign</tt></i> determines where
--   <i><tt>column</tt></i> is placed. Both are expected to be between 0.0
--   and 1.0. 0.0 means left/top alignment, 1.0 means right/bottom
--   alignment, 0.5 means center.
--   
--   If <i><tt>useAlign</tt></i> is <a>False</a>, then the alignment
--   arguments are ignored, and the tree does the minimum amount of work to
--   scroll the item onto the screen. This means that the item will be
--   scrolled to the edge closest to its current position. If the item is
--   currently visible on the screen, nothing is done.
--   
--   This function only works if the model is set, and <i><tt>path</tt></i>
--   is a valid row on the model. If the model changes before the
--   <i><tt>iconView</tt></i> is realized, the centered path will be
--   modified to reflect this change.
--   
--   <i>Since: 2.8</i>
iconViewScrollToPath :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> Bool -> Float -> Float -> m ()

-- | Selects all the icons. <i><tt>iconView</tt></i> must has its selection
--   mode set to <tt><i>GTK_SELECTION_MULTIPLE</i></tt>.
--   
--   <i>Since: 2.6</i>
iconViewSelectAll :: (HasCallStack, MonadIO m, IsIconView a) => a -> m ()

-- | Selects the row at <i><tt>path</tt></i>.
--   
--   <i>Since: 2.6</i>
iconViewSelectPath :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m ()

-- | Causes the <a>IconView::itemActivated</a> signal to be emitted on a
--   single click instead of a double click.
--   
--   <i>Since: 3.8</i>
iconViewSetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsIconView a) => a -> Bool -> m ()

-- | Sets the <a>columnSpacing</a> property which specifies the space which
--   is inserted between the columns of the icon view.
--   
--   <i>Since: 2.6</i>
iconViewSetColumnSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the <a>columns</a> property which determines in how many columns
--   the icons are arranged. If <i><tt>columns</tt></i> is -1, the number
--   of columns will be chosen automatically to fill the available area.
--   
--   <i>Since: 2.6</i>
iconViewSetColumns :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the current keyboard focus to be at <i><tt>path</tt></i>, and
--   selects it. This is useful when you want to focus the user’s attention
--   on a particular item. If <i><tt>cell</tt></i> is not <a>Nothing</a>,
--   then focus is given to the cell specified by it. Additionally, if
--   <i><tt>startEditing</tt></i> is <a>True</a>, then editing should be
--   started in the specified cell.
--   
--   This function is often followed by <tt>gtk_widget_grab_focus
--   (icon_view)</tt> in order to give keyboard focus to the widget. Please
--   note that editing can only happen when the widget is realized.
--   
--   <i>Since: 2.8</i>
iconViewSetCursor :: (HasCallStack, MonadIO m, IsIconView a, IsCellRenderer b) => a -> TreePath -> Maybe b -> Bool -> m ()

-- | Sets the item that is highlighted for feedback.
--   
--   <i>Since: 2.8</i>
iconViewSetDragDestItem :: (HasCallStack, MonadIO m, IsIconView a) => a -> Maybe TreePath -> IconViewDropPosition -> m ()

-- | Sets the <a>itemOrientation</a> property which determines whether the
--   labels are drawn beside the icons instead of below.
--   
--   <i>Since: 2.6</i>
iconViewSetItemOrientation :: (HasCallStack, MonadIO m, IsIconView a) => a -> Orientation -> m ()

-- | Sets the <a>IconView:itemPadding</a> property which specifies the
--   padding around each of the icon view’s items.
--   
--   <i>Since: 2.18</i>
iconViewSetItemPadding :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the <a>itemWidth</a> property which specifies the width to use
--   for each item. If it is set to -1, the icon view will automatically
--   determine a suitable item size.
--   
--   <i>Since: 2.6</i>
iconViewSetItemWidth :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the <a>margin</a> property which specifies the space which is
--   inserted at the top, bottom, left and right of the icon view.
--   
--   <i>Since: 2.6</i>
iconViewSetMargin :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the column with markup information for <i><tt>iconView</tt></i>
--   to be <i><tt>column</tt></i>. The markup column must be of type
--   <tt><i>G_TYPE_STRING</i></tt>. If the markup column is set to
--   something, it overrides the text column set by
--   <a>iconViewSetTextColumn</a>.
--   
--   <i>Since: 2.6</i>
iconViewSetMarkupColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the model for a <a>IconView</a>. If the <i><tt>iconView</tt></i>
--   already has a model set, it will remove it before setting the new
--   model. If <i><tt>model</tt></i> is <a>Nothing</a>, then it will unset
--   the old model.
--   
--   <i>Since: 2.6</i>
iconViewSetModel :: (HasCallStack, MonadIO m, IsIconView a, IsTreeModel b) => a -> Maybe b -> m ()

-- | Sets the column with pixbufs for <i><tt>iconView</tt></i> to be
--   <i><tt>column</tt></i>. The pixbuf column must be of type
--   <tt><i>GDK_TYPE_PIXBUF</i></tt>
--   
--   <i>Since: 2.6</i>
iconViewSetPixbufColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | This function is a convenience function to allow you to reorder models
--   that support the <a>TreeDragSourceIface</a> and the
--   <a>TreeDragDestIface</a>. Both <a>TreeStore</a> and <a>ListStore</a>
--   support these. If <i><tt>reorderable</tt></i> is <a>True</a>, then the
--   user can reorder the model by dragging and dropping rows. The
--   developer can listen to these changes by connecting to the model's
--   row_inserted and row_deleted signals. The reordering is implemented by
--   setting up the icon view as a drag source and destination. Therefore,
--   drag and drop can not be used in a reorderable view for any other
--   purpose.
--   
--   This function does not give you any degree of control over the order
--   -- any reordering is allowed. If more control is needed, you should
--   probably handle drag and drop manually.
--   
--   <i>Since: 2.8</i>
iconViewSetReorderable :: (HasCallStack, MonadIO m, IsIconView a) => a -> Bool -> m ()

-- | Sets the <a>rowSpacing</a> property which specifies the space which is
--   inserted between the rows of the icon view.
--   
--   <i>Since: 2.6</i>
iconViewSetRowSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the selection mode of the <i><tt>iconView</tt></i>.
--   
--   <i>Since: 2.6</i>
iconViewSetSelectionMode :: (HasCallStack, MonadIO m, IsIconView a) => a -> SelectionMode -> m ()

-- | Sets the <a>spacing</a> property which specifies the space which is
--   inserted between the cells (i.e. the icon and the text) of an item.
--   
--   <i>Since: 2.6</i>
iconViewSetSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the column with text for <i><tt>iconView</tt></i> to be
--   <i><tt>column</tt></i>. The text column must be of type
--   <tt><i>G_TYPE_STRING</i></tt>.
--   
--   <i>Since: 2.6</i>
iconViewSetTextColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the tip area of <i><tt>tooltip</tt></i> to the area which
--   <i><tt>cell</tt></i> occupies in the item pointed to by
--   <i><tt>path</tt></i>. See also <a>tooltipSetTipArea</a>.
--   
--   See also <a>iconViewSetTooltipColumn</a> for a simpler alternative.
--   
--   <i>Since: 2.12</i>
iconViewSetTooltipCell :: (HasCallStack, MonadIO m, IsIconView a, IsTooltip b, IsCellRenderer c) => a -> b -> TreePath -> Maybe c -> m ()

-- | If you only plan to have simple (text-only) tooltips on full items,
--   you can use this function to have <a>IconView</a> handle these
--   automatically for you. <i><tt>column</tt></i> should be set to the
--   column in <i><tt>iconView</tt></i>’s model containing the tooltip
--   texts, or -1 to disable this feature.
--   
--   When enabled, <a>Widget:hasTooltip</a> will be set to <a>True</a> and
--   <i><tt>iconView</tt></i> will connect a <a>Widget::queryTooltip</a>
--   signal handler.
--   
--   Note that the signal handler sets the text with
--   <a>tooltipSetMarkup</a>, so &amp;, &lt;, etc have to be escaped in the
--   text.
--   
--   <i>Since: 2.12</i>
iconViewSetTooltipColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the tip area of <i><tt>tooltip</tt></i> to be the area covered by
--   the item at <i><tt>path</tt></i>. See also
--   <a>iconViewSetTooltipColumn</a> for a simpler alternative. See also
--   <a>tooltipSetTipArea</a>.
--   
--   <i>Since: 2.12</i>
iconViewSetTooltipItem :: (HasCallStack, MonadIO m, IsIconView a, IsTooltip b) => a -> b -> TreePath -> m ()

-- | Unselects all the icons.
--   
--   <i>Since: 2.6</i>
iconViewUnselectAll :: (HasCallStack, MonadIO m, IsIconView a) => a -> m ()

-- | Unselects the row at <i><tt>path</tt></i>.
--   
--   <i>Since: 2.6</i>
iconViewUnselectPath :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m ()

-- | Undoes the effect of <a>iconViewEnableModelDragDest</a>. Calling this
--   method sets <a>IconView:reorderable</a> to <a>False</a>.
--   
--   <i>Since: 2.8</i>
iconViewUnsetModelDragDest :: (HasCallStack, MonadIO m, IsIconView a) => a -> m ()

-- | Undoes the effect of <a>iconViewEnableModelDragSource</a>. Calling
--   this method sets <a>IconView:reorderable</a> to <a>False</a>.
--   
--   <i>Since: 2.8</i>
iconViewUnsetModelDragSource :: (HasCallStack, MonadIO m, IsIconView a) => a -> m ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> flowBoxChild #activate callback
--   </pre>
onFlowBoxChildActivate :: (IsFlowBoxChild a, MonadIO m) => a -> ((?self :: a) => FlowBoxChildActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> flowBoxChild #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFlowBoxChildActivate :: (IsFlowBoxChild a, MonadIO m) => a -> ((?self :: a) => FlowBoxChildActivateCallback) -> m SignalHandlerId

-- | Creates a new <a>FlowBoxChild</a>, to be used as a child of a
--   <a>FlowBox</a>.
--   
--   <i>Since: 3.12</i>
flowBoxChildNew :: (HasCallStack, MonadIO m) => m FlowBoxChild

-- | Gets the current index of the <i><tt>child</tt></i> in its
--   <a>FlowBox</a> container.
--   
--   <i>Since: 3.12</i>
flowBoxChildGetIndex :: (HasCallStack, MonadIO m, IsFlowBoxChild a) => a -> m Int32

-- | Returns whether the <i><tt>child</tt></i> is currently selected in its
--   <a>FlowBox</a> container.
--   
--   <i>Since: 3.12</i>
flowBoxChildIsSelected :: (HasCallStack, MonadIO m, IsFlowBoxChild a) => a -> m Bool

-- | Connect a signal handler for the <a>activateCursorChild</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> flowBox #activateCursorChild callback
--   </pre>
onFlowBoxActivateCursorChild :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxActivateCursorChildCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateCursorChild</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> flowBox #activateCursorChild callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFlowBoxActivateCursorChild :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxActivateCursorChildCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>childActivated</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> flowBox #childActivated callback
--   </pre>
onFlowBoxChildActivated :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxChildActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>childActivated</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> flowBox #childActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFlowBoxChildActivated :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxChildActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> flowBox #moveCursor callback
--   </pre>
onFlowBoxMoveCursor :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> flowBox #moveCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFlowBoxMoveCursor :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> flowBox #selectAll callback
--   </pre>
onFlowBoxSelectAll :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> flowBox #selectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFlowBoxSelectAll :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectedChildrenChanged</a>
--   signal, to be run before the default handler. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> flowBox #selectedChildrenChanged callback
--   </pre>
onFlowBoxSelectedChildrenChanged :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxSelectedChildrenChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectedChildrenChanged</a>
--   signal, to be run after the default handler. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> flowBox #selectedChildrenChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFlowBoxSelectedChildrenChanged :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxSelectedChildrenChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleCursorChild</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> flowBox #toggleCursorChild callback
--   </pre>
onFlowBoxToggleCursorChild :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxToggleCursorChildCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleCursorChild</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> flowBox #toggleCursorChild callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFlowBoxToggleCursorChild :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxToggleCursorChildCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unselectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> flowBox #unselectAll callback
--   </pre>
onFlowBoxUnselectAll :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxUnselectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unselectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> flowBox #unselectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFlowBoxUnselectAll :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxUnselectAllCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>activate-on-single-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flowBox #activateOnSingleClick
--   </pre>
getFlowBoxActivateOnSingleClick :: (MonadIO m, IsFlowBox o) => o -> m Bool

-- | Set the value of the “<tt>activate-on-single-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flowBox [ #activateOnSingleClick <a>:=</a> value ]
--   </pre>
setFlowBoxActivateOnSingleClick :: (MonadIO m, IsFlowBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activate-on-single-click</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructFlowBoxActivateOnSingleClick :: (IsFlowBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>column-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flowBox #columnSpacing
--   </pre>
getFlowBoxColumnSpacing :: (MonadIO m, IsFlowBox o) => o -> m Word32

-- | Set the value of the “<tt>column-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flowBox [ #columnSpacing <a>:=</a> value ]
--   </pre>
setFlowBoxColumnSpacing :: (MonadIO m, IsFlowBox o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>column-spacing</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructFlowBoxColumnSpacing :: (IsFlowBox o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flowBox #homogeneous
--   </pre>
getFlowBoxHomogeneous :: (MonadIO m, IsFlowBox o) => o -> m Bool

-- | Set the value of the “<tt>homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flowBox [ #homogeneous <a>:=</a> value ]
--   </pre>
setFlowBoxHomogeneous :: (MonadIO m, IsFlowBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>homogeneous</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFlowBoxHomogeneous :: (IsFlowBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-children-per-line</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flowBox #maxChildrenPerLine
--   </pre>
getFlowBoxMaxChildrenPerLine :: (MonadIO m, IsFlowBox o) => o -> m Word32

-- | Set the value of the “<tt>max-children-per-line</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flowBox [ #maxChildrenPerLine <a>:=</a> value ]
--   </pre>
setFlowBoxMaxChildrenPerLine :: (MonadIO m, IsFlowBox o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-children-per-line</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructFlowBoxMaxChildrenPerLine :: (IsFlowBox o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>min-children-per-line</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flowBox #minChildrenPerLine
--   </pre>
getFlowBoxMinChildrenPerLine :: (MonadIO m, IsFlowBox o) => o -> m Word32

-- | Set the value of the “<tt>min-children-per-line</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flowBox [ #minChildrenPerLine <a>:=</a> value ]
--   </pre>
setFlowBoxMinChildrenPerLine :: (MonadIO m, IsFlowBox o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>min-children-per-line</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructFlowBoxMinChildrenPerLine :: (IsFlowBox o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>row-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flowBox #rowSpacing
--   </pre>
getFlowBoxRowSpacing :: (MonadIO m, IsFlowBox o) => o -> m Word32

-- | Set the value of the “<tt>row-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flowBox [ #rowSpacing <a>:=</a> value ]
--   </pre>
setFlowBoxRowSpacing :: (MonadIO m, IsFlowBox o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>row-spacing</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFlowBoxRowSpacing :: (IsFlowBox o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>selection-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flowBox #selectionMode
--   </pre>
getFlowBoxSelectionMode :: (MonadIO m, IsFlowBox o) => o -> m SelectionMode

-- | Set the value of the “<tt>selection-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flowBox [ #selectionMode <a>:=</a> value ]
--   </pre>
setFlowBoxSelectionMode :: (MonadIO m, IsFlowBox o) => o -> SelectionMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>selection-mode</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructFlowBoxSelectionMode :: (IsFlowBox o, MonadIO m) => SelectionMode -> m (GValueConstruct o)

-- | Creates a GtkFlowBox.
--   
--   <i>Since: 3.12</i>
flowBoxNew :: (HasCallStack, MonadIO m) => m FlowBox

-- | Returns whether children activate on single clicks.
--   
--   <i>Since: 3.12</i>
flowBoxGetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Bool

-- | Gets the nth child in the <i><tt>box</tt></i>.
--   
--   <i>Since: 3.12</i>
flowBoxGetChildAtIndex :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Int32 -> m (Maybe FlowBoxChild)

-- | Gets the child in the (<i><tt>x</tt></i>, <i><tt>y</tt></i>) position.
--   
--   <i>Since: 3.22.6</i>
flowBoxGetChildAtPos :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Int32 -> Int32 -> m (Maybe FlowBoxChild)

-- | Gets the horizontal spacing.
--   
--   <i>Since: 3.12</i>
flowBoxGetColumnSpacing :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Word32

-- | Returns whether the box is homogeneous (all children are the same
--   size). See <a>boxSetHomogeneous</a>.
--   
--   <i>Since: 3.12</i>
flowBoxGetHomogeneous :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Bool

-- | Gets the maximum number of children per line.
--   
--   <i>Since: 3.12</i>
flowBoxGetMaxChildrenPerLine :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Word32

-- | Gets the minimum number of children per line.
--   
--   <i>Since: 3.12</i>
flowBoxGetMinChildrenPerLine :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Word32

-- | Gets the vertical spacing.
--   
--   <i>Since: 3.12</i>
flowBoxGetRowSpacing :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Word32

-- | Creates a list of all selected children.
--   
--   <i>Since: 3.12</i>
flowBoxGetSelectedChildren :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m [FlowBoxChild]

-- | Gets the selection mode of <i><tt>box</tt></i>.
--   
--   <i>Since: 3.12</i>
flowBoxGetSelectionMode :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m SelectionMode

-- | Inserts the <i><tt>widget</tt></i> into <i><tt>box</tt></i> at
--   <i><tt>position</tt></i>.
--   
--   If a sort function is set, the widget will actually be inserted at the
--   calculated position and this function has the same effect as
--   <a>containerAdd</a>.
--   
--   If <i><tt>position</tt></i> is -1, or larger than the total number of
--   children in the <i><tt>box</tt></i>, then the <i><tt>widget</tt></i>
--   will be appended to the end.
--   
--   <i>Since: 3.12</i>
flowBoxInsert :: (HasCallStack, MonadIO m, IsFlowBox a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Updates the filtering for all children.
--   
--   Call this function when the result of the filter function on the
--   <i><tt>box</tt></i> is changed due ot an external factor. For
--   instance, this would be used if the filter function just looked for a
--   specific search term, and the entry with the string has changed.
--   
--   <i>Since: 3.12</i>
flowBoxInvalidateFilter :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m ()

-- | Select all children of <i><tt>box</tt></i>, if the selection mode
--   allows it.
--   
--   <i>Since: 3.12</i>
flowBoxSelectAll :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m ()

-- | Selects a single child of <i><tt>box</tt></i>, if the selection mode
--   allows it.
--   
--   <i>Since: 3.12</i>
flowBoxSelectChild :: (HasCallStack, MonadIO m, IsFlowBox a, IsFlowBoxChild b) => a -> b -> m ()

-- | If <i><tt>single</tt></i> is <a>True</a>, children will be activated
--   when you click on them, otherwise you need to double-click.
--   
--   <i>Since: 3.12</i>
flowBoxSetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Bool -> m ()

-- | Sets the horizontal space to add between children. See the
--   <a>FlowBox:columnSpacing</a> property.
--   
--   <i>Since: 3.12</i>
flowBoxSetColumnSpacing :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Word32 -> m ()

-- | By setting a filter function on the <i><tt>box</tt></i> one can decide
--   dynamically which of the children to show. For instance, to implement
--   a search function that only shows the children matching the search
--   terms.
--   
--   The <i><tt>filterFunc</tt></i> will be called for each child after the
--   call, and it will continue to be called each time a child changes (via
--   <a>flowBoxChildChanged</a>) or when <a>flowBoxInvalidateFilter</a> is
--   called.
--   
--   Note that using a filter function is incompatible with using a model
--   (see <a>flowBoxBindModel</a>).
--   
--   <i>Since: 3.12</i>
flowBoxSetFilterFunc :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Maybe FlowBoxFilterFunc -> m ()

-- | Hooks up an adjustment to focus handling in <i><tt>box</tt></i>. The
--   adjustment is also used for autoscrolling during rubberband selection.
--   See <a>scrolledWindowGetHadjustment</a> for a typical way of obtaining
--   the adjustment, and <a>flowBoxSetVadjustment</a>for setting the
--   vertical adjustment.
--   
--   The adjustments have to be in pixel units and in the same coordinate
--   system as the allocation for immediate children of the box.
--   
--   <i>Since: 3.12</i>
flowBoxSetHadjustment :: (HasCallStack, MonadIO m, IsFlowBox a, IsAdjustment b) => a -> b -> m ()

-- | Sets the <a>FlowBox:homogeneous</a> property of <i><tt>box</tt></i>,
--   controlling whether or not all children of <i><tt>box</tt></i> are
--   given equal space in the box.
--   
--   <i>Since: 3.12</i>
flowBoxSetHomogeneous :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Bool -> m ()

-- | Sets the maximum number of children to request and allocate space for
--   in <i><tt>box</tt></i>’s orientation.
--   
--   Setting the maximum number of children per line limits the overall
--   natural size request to be no more than <i><tt>nChildren</tt></i>
--   children long in the given orientation.
--   
--   <i>Since: 3.12</i>
flowBoxSetMaxChildrenPerLine :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Word32 -> m ()

-- | Sets the minimum number of children to line up in
--   <i><tt>box</tt></i>’s orientation before flowing.
--   
--   <i>Since: 3.12</i>
flowBoxSetMinChildrenPerLine :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Word32 -> m ()

-- | Sets the vertical space to add between children. See the
--   <a>FlowBox:rowSpacing</a> property.
--   
--   <i>Since: 3.12</i>
flowBoxSetRowSpacing :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Word32 -> m ()

-- | Sets how selection works in <i><tt>box</tt></i>. See
--   <a>SelectionMode</a> for details.
--   
--   <i>Since: 3.12</i>
flowBoxSetSelectionMode :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> SelectionMode -> m ()

-- | By setting a sort function on the <i><tt>box</tt></i>, one can
--   dynamically reorder the children of the box, based on the contents of
--   the children.
--   
--   The <i><tt>sortFunc</tt></i> will be called for each child after the
--   call, and will continue to be called each time a child changes (via
--   <a>flowBoxChildChanged</a>) and when <a>flowBoxInvalidateSort</a> is
--   called.
--   
--   Note that using a sort function is incompatible with using a model
--   (see <a>flowBoxBindModel</a>).
--   
--   <i>Since: 3.12</i>
flowBoxSetSortFunc :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Maybe FlowBoxSortFunc -> m ()

-- | Hooks up an adjustment to focus handling in <i><tt>box</tt></i>. The
--   adjustment is also used for autoscrolling during rubberband selection.
--   See <a>scrolledWindowGetVadjustment</a> for a typical way of obtaining
--   the adjustment, and <a>flowBoxSetHadjustment</a>for setting the
--   horizontal adjustment.
--   
--   The adjustments have to be in pixel units and in the same coordinate
--   system as the allocation for immediate children of the box.
--   
--   <i>Since: 3.12</i>
flowBoxSetVadjustment :: (HasCallStack, MonadIO m, IsFlowBox a, IsAdjustment b) => a -> b -> m ()

-- | Unselect all children of <i><tt>box</tt></i>, if the selection mode
--   allows it.
--   
--   <i>Since: 3.12</i>
flowBoxUnselectAll :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m ()

-- | Unselects a single child of <i><tt>box</tt></i>, if the selection mode
--   allows it.
--   
--   <i>Since: 3.12</i>
flowBoxUnselectChild :: (HasCallStack, MonadIO m, IsFlowBox a, IsFlowBoxChild b) => a -> b -> m ()

-- | Connect a signal handler for the <a>daySelected</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> calendar #daySelected callback
--   </pre>
onCalendarDaySelected :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarDaySelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>daySelected</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> calendar #daySelected callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCalendarDaySelected :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarDaySelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>daySelectedDoubleClick</a> signal,
--   to be run before the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> calendar #daySelectedDoubleClick callback
--   </pre>
onCalendarDaySelectedDoubleClick :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarDaySelectedDoubleClickCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>daySelectedDoubleClick</a> signal,
--   to be run after the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> calendar #daySelectedDoubleClick callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCalendarDaySelectedDoubleClick :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarDaySelectedDoubleClickCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>monthChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> calendar #monthChanged callback
--   </pre>
onCalendarMonthChanged :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarMonthChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>monthChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> calendar #monthChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCalendarMonthChanged :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarMonthChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>nextMonth</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> calendar #nextMonth callback
--   </pre>
onCalendarNextMonth :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarNextMonthCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>nextMonth</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> calendar #nextMonth callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCalendarNextMonth :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarNextMonthCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>nextYear</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> calendar #nextYear callback
--   </pre>
onCalendarNextYear :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarNextYearCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>nextYear</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> calendar #nextYear callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCalendarNextYear :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarNextYearCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>prevMonth</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> calendar #prevMonth callback
--   </pre>
onCalendarPrevMonth :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarPrevMonthCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>prevMonth</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> calendar #prevMonth callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCalendarPrevMonth :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarPrevMonthCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>prevYear</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> calendar #prevYear callback
--   </pre>
onCalendarPrevYear :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarPrevYearCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>prevYear</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> calendar #prevYear callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCalendarPrevYear :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarPrevYearCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>day</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #day
--   </pre>
getCalendarDay :: (MonadIO m, IsCalendar o) => o -> m Int32

-- | Set the value of the “<tt>day</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #day <a>:=</a> value ]
--   </pre>
setCalendarDay :: (MonadIO m, IsCalendar o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>day</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCalendarDay :: (IsCalendar o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>detail-height-rows</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #detailHeightRows
--   </pre>
getCalendarDetailHeightRows :: (MonadIO m, IsCalendar o) => o -> m Int32

-- | Set the value of the “<tt>detail-height-rows</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #detailHeightRows <a>:=</a> value ]
--   </pre>
setCalendarDetailHeightRows :: (MonadIO m, IsCalendar o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>detail-height-rows</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCalendarDetailHeightRows :: (IsCalendar o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>detail-width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #detailWidthChars
--   </pre>
getCalendarDetailWidthChars :: (MonadIO m, IsCalendar o) => o -> m Int32

-- | Set the value of the “<tt>detail-width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #detailWidthChars <a>:=</a> value ]
--   </pre>
setCalendarDetailWidthChars :: (MonadIO m, IsCalendar o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>detail-width-chars</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCalendarDetailWidthChars :: (IsCalendar o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>month</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #month
--   </pre>
getCalendarMonth :: (MonadIO m, IsCalendar o) => o -> m Int32

-- | Set the value of the “<tt>month</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #month <a>:=</a> value ]
--   </pre>
setCalendarMonth :: (MonadIO m, IsCalendar o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>month</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCalendarMonth :: (IsCalendar o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>no-month-change</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #noMonthChange
--   </pre>
getCalendarNoMonthChange :: (MonadIO m, IsCalendar o) => o -> m Bool

-- | Set the value of the “<tt>no-month-change</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #noMonthChange <a>:=</a> value ]
--   </pre>
setCalendarNoMonthChange :: (MonadIO m, IsCalendar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>no-month-change</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCalendarNoMonthChange :: (IsCalendar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-day-names</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #showDayNames
--   </pre>
getCalendarShowDayNames :: (MonadIO m, IsCalendar o) => o -> m Bool

-- | Set the value of the “<tt>show-day-names</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #showDayNames <a>:=</a> value ]
--   </pre>
setCalendarShowDayNames :: (MonadIO m, IsCalendar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-day-names</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCalendarShowDayNames :: (IsCalendar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-details</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #showDetails
--   </pre>
getCalendarShowDetails :: (MonadIO m, IsCalendar o) => o -> m Bool

-- | Set the value of the “<tt>show-details</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #showDetails <a>:=</a> value ]
--   </pre>
setCalendarShowDetails :: (MonadIO m, IsCalendar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-details</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCalendarShowDetails :: (IsCalendar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-heading</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #showHeading
--   </pre>
getCalendarShowHeading :: (MonadIO m, IsCalendar o) => o -> m Bool

-- | Set the value of the “<tt>show-heading</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #showHeading <a>:=</a> value ]
--   </pre>
setCalendarShowHeading :: (MonadIO m, IsCalendar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-heading</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCalendarShowHeading :: (IsCalendar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-week-numbers</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #showWeekNumbers
--   </pre>
getCalendarShowWeekNumbers :: (MonadIO m, IsCalendar o) => o -> m Bool

-- | Set the value of the “<tt>show-week-numbers</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #showWeekNumbers <a>:=</a> value ]
--   </pre>
setCalendarShowWeekNumbers :: (MonadIO m, IsCalendar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-week-numbers</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCalendarShowWeekNumbers :: (IsCalendar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>year</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #year
--   </pre>
getCalendarYear :: (MonadIO m, IsCalendar o) => o -> m Int32

-- | Set the value of the “<tt>year</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #year <a>:=</a> value ]
--   </pre>
setCalendarYear :: (MonadIO m, IsCalendar o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>year</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCalendarYear :: (IsCalendar o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new calendar, with the current date being selected.
calendarNew :: (HasCallStack, MonadIO m) => m Calendar

-- | Remove all visual markers.
calendarClearMarks :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m ()

-- | Obtains the selected date from a <a>Calendar</a>.
calendarGetDate :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m (Word32, Word32, Word32)

-- | Returns if the <i><tt>day</tt></i> of the <i><tt>calendar</tt></i> is
--   already marked.
--   
--   <i>Since: 3.0</i>
calendarGetDayIsMarked :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Word32 -> m Bool

-- | Queries the height of detail cells, in rows. See
--   <a>Calendar:detailWidthChars</a>.
--   
--   <i>Since: 2.14</i>
calendarGetDetailHeightRows :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m Int32

-- | Queries the width of detail cells, in characters. See
--   <a>Calendar:detailWidthChars</a>.
--   
--   <i>Since: 2.14</i>
calendarGetDetailWidthChars :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m Int32

-- | Returns the current display options of <i><tt>calendar</tt></i>.
--   
--   <i>Since: 2.4</i>
calendarGetDisplayOptions :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m [CalendarDisplayOptions]

-- | Places a visual marker on a particular day.
calendarMarkDay :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Word32 -> m ()

-- | Selects a day from the current month.
calendarSelectDay :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Word32 -> m ()

-- | Shifts the calendar to a different month.
calendarSelectMonth :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Word32 -> Word32 -> m ()

-- | Updates the height of detail cells. See
--   <a>Calendar:detailHeightRows</a>.
--   
--   <i>Since: 2.14</i>
calendarSetDetailHeightRows :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Int32 -> m ()

-- | Updates the width of detail cells. See
--   <a>Calendar:detailWidthChars</a>.
--   
--   <i>Since: 2.14</i>
calendarSetDetailWidthChars :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Int32 -> m ()

-- | Sets display options (whether to display the heading and the month
--   headings).
--   
--   <i>Since: 2.4</i>
calendarSetDisplayOptions :: (HasCallStack, MonadIO m, IsCalendar a) => a -> [CalendarDisplayOptions] -> m ()

-- | Removes the visual marker from a particular day.
calendarUnmarkDay :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Word32 -> m ()

-- | Construct a <a>WidgetClass</a> struct initialized to zero.
newZeroWidgetClass :: MonadIO m => m WidgetClass

-- | Get the value of the “<tt>parent_class</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #parentClass
--   </pre>
getWidgetClassParentClass :: MonadIO m => WidgetClass -> m InitiallyUnownedClass

-- | Get the value of the “<tt>activate_signal</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #activateSignal
--   </pre>
getWidgetClassActivateSignal :: MonadIO m => WidgetClass -> m Word32

-- | Set the value of the “<tt>activate_signal</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #activateSignal <a>:=</a> value ]
--   </pre>
setWidgetClassActivateSignal :: MonadIO m => WidgetClass -> Word32 -> m ()

-- | Get the value of the “<tt>dispatch_child_properties_changed</tt>”
--   field. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #dispatchChildPropertiesChanged
--   </pre>
getWidgetClassDispatchChildPropertiesChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback)

-- | Set the value of the “<tt>dispatch_child_properties_changed</tt>”
--   field. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #dispatchChildPropertiesChanged <a>:=</a> value ]
--   </pre>
setWidgetClassDispatchChildPropertiesChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback -> m ()

-- | Set the value of the “<tt>dispatch_child_properties_changed</tt>”
--   field to <a>Nothing</a>. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>clear</a> #dispatchChildPropertiesChanged
--   </pre>
clearWidgetClassDispatchChildPropertiesChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>destroy</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #destroy
--   </pre>
getWidgetClassDestroy :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)

-- | Set the value of the “<tt>destroy</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #destroy <a>:=</a> value ]
--   </pre>
setWidgetClassDestroy :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()

-- | Set the value of the “<tt>destroy</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #destroy
--   </pre>
clearWidgetClassDestroy :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>show</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #show
--   </pre>
getWidgetClassShow :: MonadIO m => WidgetClass -> m (Maybe WidgetClassShowFieldCallback)

-- | Set the value of the “<tt>show</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #show <a>:=</a> value ]
--   </pre>
setWidgetClassShow :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()

-- | Set the value of the “<tt>show</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #show
--   </pre>
clearWidgetClassShow :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>show_all</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #showAll
--   </pre>
getWidgetClassShowAll :: MonadIO m => WidgetClass -> m (Maybe WidgetClassShowAllFieldCallback)

-- | Set the value of the “<tt>show_all</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #showAll <a>:=</a> value ]
--   </pre>
setWidgetClassShowAll :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassShowAllFieldCallback -> m ()

-- | Set the value of the “<tt>show_all</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #showAll
--   </pre>
clearWidgetClassShowAll :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>hide</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #hide
--   </pre>
getWidgetClassHide :: MonadIO m => WidgetClass -> m (Maybe WidgetClassHideFieldCallback)

-- | Set the value of the “<tt>hide</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #hide <a>:=</a> value ]
--   </pre>
setWidgetClassHide :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassHideFieldCallback -> m ()

-- | Set the value of the “<tt>hide</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #hide
--   </pre>
clearWidgetClassHide :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>map</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #map
--   </pre>
getWidgetClassMap :: MonadIO m => WidgetClass -> m (Maybe WidgetClassMapFieldCallback)

-- | Set the value of the “<tt>map</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #map <a>:=</a> value ]
--   </pre>
setWidgetClassMap :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassMapFieldCallback -> m ()

-- | Set the value of the “<tt>map</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #map
--   </pre>
clearWidgetClassMap :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>unmap</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #unmap
--   </pre>
getWidgetClassUnmap :: MonadIO m => WidgetClass -> m (Maybe WidgetClassUnmapFieldCallback)

-- | Set the value of the “<tt>unmap</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #unmap <a>:=</a> value ]
--   </pre>
setWidgetClassUnmap :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassUnmapFieldCallback -> m ()

-- | Set the value of the “<tt>unmap</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #unmap
--   </pre>
clearWidgetClassUnmap :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>realize</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #realize
--   </pre>
getWidgetClassRealize :: MonadIO m => WidgetClass -> m (Maybe WidgetClassRealizeFieldCallback)

-- | Set the value of the “<tt>realize</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #realize <a>:=</a> value ]
--   </pre>
setWidgetClassRealize :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassRealizeFieldCallback -> m ()

-- | Set the value of the “<tt>realize</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #realize
--   </pre>
clearWidgetClassRealize :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>unrealize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #unrealize
--   </pre>
getWidgetClassUnrealize :: MonadIO m => WidgetClass -> m (Maybe WidgetClassUnrealizeFieldCallback)

-- | Set the value of the “<tt>unrealize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #unrealize <a>:=</a> value ]
--   </pre>
setWidgetClassUnrealize :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassUnrealizeFieldCallback -> m ()

-- | Set the value of the “<tt>unrealize</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #unrealize
--   </pre>
clearWidgetClassUnrealize :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>size_allocate</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #sizeAllocate
--   </pre>
getWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> m (Maybe WidgetClassSizeAllocateFieldCallback)

-- | Set the value of the “<tt>size_allocate</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #sizeAllocate <a>:=</a> value ]
--   </pre>
setWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassSizeAllocateFieldCallback -> m ()

-- | Set the value of the “<tt>size_allocate</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #sizeAllocate
--   </pre>
clearWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>state_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #stateChanged
--   </pre>
getWidgetClassStateChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassStateChangedFieldCallback)

-- | Set the value of the “<tt>state_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #stateChanged <a>:=</a> value ]
--   </pre>
setWidgetClassStateChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassStateChangedFieldCallback -> m ()

-- | Set the value of the “<tt>state_changed</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #stateChanged
--   </pre>
clearWidgetClassStateChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>state_flags_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #stateFlagsChanged
--   </pre>
getWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassStateFlagsChangedFieldCallback)

-- | Set the value of the “<tt>state_flags_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #stateFlagsChanged <a>:=</a> value ]
--   </pre>
setWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()

-- | Set the value of the “<tt>state_flags_changed</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #stateFlagsChanged
--   </pre>
clearWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>parent_set</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #parentSet
--   </pre>
getWidgetClassParentSet :: MonadIO m => WidgetClass -> m (Maybe WidgetClassParentSetFieldCallback)

-- | Set the value of the “<tt>parent_set</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #parentSet <a>:=</a> value ]
--   </pre>
setWidgetClassParentSet :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassParentSetFieldCallback -> m ()

-- | Set the value of the “<tt>parent_set</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #parentSet
--   </pre>
clearWidgetClassParentSet :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>hierarchy_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #hierarchyChanged
--   </pre>
getWidgetClassHierarchyChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassHierarchyChangedFieldCallback)

-- | Set the value of the “<tt>hierarchy_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #hierarchyChanged <a>:=</a> value ]
--   </pre>
setWidgetClassHierarchyChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassHierarchyChangedFieldCallback -> m ()

-- | Set the value of the “<tt>hierarchy_changed</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #hierarchyChanged
--   </pre>
clearWidgetClassHierarchyChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>style_set</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #styleSet
--   </pre>
getWidgetClassStyleSet :: MonadIO m => WidgetClass -> m (Maybe WidgetClassStyleSetFieldCallback)

-- | Set the value of the “<tt>style_set</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #styleSet <a>:=</a> value ]
--   </pre>
setWidgetClassStyleSet :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassStyleSetFieldCallback -> m ()

-- | Set the value of the “<tt>style_set</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #styleSet
--   </pre>
clearWidgetClassStyleSet :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>direction_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #directionChanged
--   </pre>
getWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDirectionChangedFieldCallback)

-- | Set the value of the “<tt>direction_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #directionChanged <a>:=</a> value ]
--   </pre>
setWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDirectionChangedFieldCallback -> m ()

-- | Set the value of the “<tt>direction_changed</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #directionChanged
--   </pre>
clearWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>grab_notify</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #grabNotify
--   </pre>
getWidgetClassGrabNotify :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGrabNotifyFieldCallback)

-- | Set the value of the “<tt>grab_notify</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #grabNotify <a>:=</a> value ]
--   </pre>
setWidgetClassGrabNotify :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGrabNotifyFieldCallback -> m ()

-- | Set the value of the “<tt>grab_notify</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #grabNotify
--   </pre>
clearWidgetClassGrabNotify :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>child_notify</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #childNotify
--   </pre>
getWidgetClassChildNotify :: MonadIO m => WidgetClass -> m (Maybe WidgetClassChildNotifyFieldCallback)

-- | Set the value of the “<tt>child_notify</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #childNotify <a>:=</a> value ]
--   </pre>
setWidgetClassChildNotify :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassChildNotifyFieldCallback -> m ()

-- | Set the value of the “<tt>child_notify</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #childNotify
--   </pre>
clearWidgetClassChildNotify :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>draw</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #draw
--   </pre>
getWidgetClassDraw :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDrawFieldCallback)

-- | Set the value of the “<tt>draw</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #draw <a>:=</a> value ]
--   </pre>
setWidgetClassDraw :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDrawFieldCallback -> m ()

-- | Set the value of the “<tt>draw</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #draw
--   </pre>
clearWidgetClassDraw :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>get_request_mode</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #getRequestMode
--   </pre>
getWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGetRequestModeFieldCallback)

-- | Set the value of the “<tt>get_request_mode</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #getRequestMode <a>:=</a> value ]
--   </pre>
setWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGetRequestModeFieldCallback -> m ()

-- | Set the value of the “<tt>get_request_mode</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #getRequestMode
--   </pre>
clearWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>get_preferred_height</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #getPreferredHeight
--   </pre>
getWidgetClassGetPreferredHeight :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGetPreferredHeightFieldCallback)

-- | Set the value of the “<tt>get_preferred_height</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #getPreferredHeight <a>:=</a> value ]
--   </pre>
setWidgetClassGetPreferredHeight :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGetPreferredHeightFieldCallback -> m ()

-- | Set the value of the “<tt>get_preferred_height</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #getPreferredHeight
--   </pre>
clearWidgetClassGetPreferredHeight :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>get_preferred_width_for_height</tt>” field.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #getPreferredWidthForHeight
--   </pre>
getWidgetClassGetPreferredWidthForHeight :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGetPreferredWidthForHeightFieldCallback)

-- | Set the value of the “<tt>get_preferred_width_for_height</tt>” field.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #getPreferredWidthForHeight <a>:=</a> value ]
--   </pre>
setWidgetClassGetPreferredWidthForHeight :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback -> m ()

-- | Set the value of the “<tt>get_preferred_width_for_height</tt>” field
--   to <a>Nothing</a>. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>clear</a> #getPreferredWidthForHeight
--   </pre>
clearWidgetClassGetPreferredWidthForHeight :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>get_preferred_width</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #getPreferredWidth
--   </pre>
getWidgetClassGetPreferredWidth :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGetPreferredWidthFieldCallback)

-- | Set the value of the “<tt>get_preferred_width</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #getPreferredWidth <a>:=</a> value ]
--   </pre>
setWidgetClassGetPreferredWidth :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGetPreferredWidthFieldCallback -> m ()

-- | Set the value of the “<tt>get_preferred_width</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #getPreferredWidth
--   </pre>
clearWidgetClassGetPreferredWidth :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>get_preferred_height_for_width</tt>” field.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #getPreferredHeightForWidth
--   </pre>
getWidgetClassGetPreferredHeightForWidth :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGetPreferredHeightForWidthFieldCallback)

-- | Set the value of the “<tt>get_preferred_height_for_width</tt>” field.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #getPreferredHeightForWidth <a>:=</a> value ]
--   </pre>
setWidgetClassGetPreferredHeightForWidth :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGetPreferredHeightForWidthFieldCallback -> m ()

-- | Set the value of the “<tt>get_preferred_height_for_width</tt>” field
--   to <a>Nothing</a>. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>clear</a> #getPreferredHeightForWidth
--   </pre>
clearWidgetClassGetPreferredHeightForWidth :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>mnemonic_activate</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #mnemonicActivate
--   </pre>
getWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> m (Maybe WidgetClassMnemonicActivateFieldCallback)

-- | Set the value of the “<tt>mnemonic_activate</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #mnemonicActivate <a>:=</a> value ]
--   </pre>
setWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassMnemonicActivateFieldCallback -> m ()

-- | Set the value of the “<tt>mnemonic_activate</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #mnemonicActivate
--   </pre>
clearWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>grab_focus</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #grabFocus
--   </pre>
getWidgetClassGrabFocus :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGrabFocusFieldCallback)

-- | Set the value of the “<tt>grab_focus</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #grabFocus <a>:=</a> value ]
--   </pre>
setWidgetClassGrabFocus :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGrabFocusFieldCallback -> m ()

-- | Set the value of the “<tt>grab_focus</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #grabFocus
--   </pre>
clearWidgetClassGrabFocus :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>focus</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #focus
--   </pre>
getWidgetClassFocus :: MonadIO m => WidgetClass -> m (Maybe WidgetClassFocusFieldCallback)

-- | Set the value of the “<tt>focus</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #focus <a>:=</a> value ]
--   </pre>
setWidgetClassFocus :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()

-- | Set the value of the “<tt>focus</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #focus
--   </pre>
clearWidgetClassFocus :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>move_focus</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #moveFocus
--   </pre>
getWidgetClassMoveFocus :: MonadIO m => WidgetClass -> m (Maybe WidgetClassMoveFocusFieldCallback)

-- | Set the value of the “<tt>move_focus</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #moveFocus <a>:=</a> value ]
--   </pre>
setWidgetClassMoveFocus :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassMoveFocusFieldCallback -> m ()

-- | Set the value of the “<tt>move_focus</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #moveFocus
--   </pre>
clearWidgetClassMoveFocus :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>keynav_failed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #keynavFailed
--   </pre>
getWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> m (Maybe WidgetClassKeynavFailedFieldCallback)

-- | Set the value of the “<tt>keynav_failed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #keynavFailed <a>:=</a> value ]
--   </pre>
setWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassKeynavFailedFieldCallback -> m ()

-- | Set the value of the “<tt>keynav_failed</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #keynavFailed
--   </pre>
clearWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>event</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #event
--   </pre>
getWidgetClassEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassEventFieldCallback)

-- | Set the value of the “<tt>event</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #event <a>:=</a> value ]
--   </pre>
setWidgetClassEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassEventFieldCallback -> m ()

-- | Set the value of the “<tt>event</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #event
--   </pre>
clearWidgetClassEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>button_press_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #buttonPressEvent
--   </pre>
getWidgetClassButtonPressEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassButtonPressEventFieldCallback)

-- | Set the value of the “<tt>button_press_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #buttonPressEvent <a>:=</a> value ]
--   </pre>
setWidgetClassButtonPressEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassButtonPressEventFieldCallback -> m ()

-- | Set the value of the “<tt>button_press_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #buttonPressEvent
--   </pre>
clearWidgetClassButtonPressEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>button_release_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #buttonReleaseEvent
--   </pre>
getWidgetClassButtonReleaseEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassButtonReleaseEventFieldCallback)

-- | Set the value of the “<tt>button_release_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #buttonReleaseEvent <a>:=</a> value ]
--   </pre>
setWidgetClassButtonReleaseEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassButtonReleaseEventFieldCallback -> m ()

-- | Set the value of the “<tt>button_release_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #buttonReleaseEvent
--   </pre>
clearWidgetClassButtonReleaseEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>scroll_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #scrollEvent
--   </pre>
getWidgetClassScrollEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassScrollEventFieldCallback)

-- | Set the value of the “<tt>scroll_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #scrollEvent <a>:=</a> value ]
--   </pre>
setWidgetClassScrollEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassScrollEventFieldCallback -> m ()

-- | Set the value of the “<tt>scroll_event</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #scrollEvent
--   </pre>
clearWidgetClassScrollEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>motion_notify_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #motionNotifyEvent
--   </pre>
getWidgetClassMotionNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassMotionNotifyEventFieldCallback)

-- | Set the value of the “<tt>motion_notify_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #motionNotifyEvent <a>:=</a> value ]
--   </pre>
setWidgetClassMotionNotifyEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassMotionNotifyEventFieldCallback -> m ()

-- | Set the value of the “<tt>motion_notify_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #motionNotifyEvent
--   </pre>
clearWidgetClassMotionNotifyEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>delete_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #deleteEvent
--   </pre>
getWidgetClassDeleteEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDeleteEventFieldCallback)

-- | Set the value of the “<tt>delete_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #deleteEvent <a>:=</a> value ]
--   </pre>
setWidgetClassDeleteEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDeleteEventFieldCallback -> m ()

-- | Set the value of the “<tt>delete_event</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #deleteEvent
--   </pre>
clearWidgetClassDeleteEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>destroy_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #destroyEvent
--   </pre>
getWidgetClassDestroyEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDestroyEventFieldCallback)

-- | Set the value of the “<tt>destroy_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #destroyEvent <a>:=</a> value ]
--   </pre>
setWidgetClassDestroyEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDestroyEventFieldCallback -> m ()

-- | Set the value of the “<tt>destroy_event</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #destroyEvent
--   </pre>
clearWidgetClassDestroyEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>key_press_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #keyPressEvent
--   </pre>
getWidgetClassKeyPressEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassKeyPressEventFieldCallback)

-- | Set the value of the “<tt>key_press_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #keyPressEvent <a>:=</a> value ]
--   </pre>
setWidgetClassKeyPressEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassKeyPressEventFieldCallback -> m ()

-- | Set the value of the “<tt>key_press_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #keyPressEvent
--   </pre>
clearWidgetClassKeyPressEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>key_release_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #keyReleaseEvent
--   </pre>
getWidgetClassKeyReleaseEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassKeyReleaseEventFieldCallback)

-- | Set the value of the “<tt>key_release_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #keyReleaseEvent <a>:=</a> value ]
--   </pre>
setWidgetClassKeyReleaseEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassKeyReleaseEventFieldCallback -> m ()

-- | Set the value of the “<tt>key_release_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #keyReleaseEvent
--   </pre>
clearWidgetClassKeyReleaseEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>enter_notify_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #enterNotifyEvent
--   </pre>
getWidgetClassEnterNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassEnterNotifyEventFieldCallback)

-- | Set the value of the “<tt>enter_notify_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #enterNotifyEvent <a>:=</a> value ]
--   </pre>
setWidgetClassEnterNotifyEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassEnterNotifyEventFieldCallback -> m ()

-- | Set the value of the “<tt>enter_notify_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #enterNotifyEvent
--   </pre>
clearWidgetClassEnterNotifyEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>leave_notify_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #leaveNotifyEvent
--   </pre>
getWidgetClassLeaveNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassLeaveNotifyEventFieldCallback)

-- | Set the value of the “<tt>leave_notify_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #leaveNotifyEvent <a>:=</a> value ]
--   </pre>
setWidgetClassLeaveNotifyEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassLeaveNotifyEventFieldCallback -> m ()

-- | Set the value of the “<tt>leave_notify_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #leaveNotifyEvent
--   </pre>
clearWidgetClassLeaveNotifyEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>configure_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #configureEvent
--   </pre>
getWidgetClassConfigureEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassConfigureEventFieldCallback)

-- | Set the value of the “<tt>configure_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #configureEvent <a>:=</a> value ]
--   </pre>
setWidgetClassConfigureEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassConfigureEventFieldCallback -> m ()

-- | Set the value of the “<tt>configure_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #configureEvent
--   </pre>
clearWidgetClassConfigureEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>focus_in_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #focusInEvent
--   </pre>
getWidgetClassFocusInEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassFocusInEventFieldCallback)

-- | Set the value of the “<tt>focus_in_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #focusInEvent <a>:=</a> value ]
--   </pre>
setWidgetClassFocusInEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassFocusInEventFieldCallback -> m ()

-- | Set the value of the “<tt>focus_in_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #focusInEvent
--   </pre>
clearWidgetClassFocusInEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>focus_out_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #focusOutEvent
--   </pre>
getWidgetClassFocusOutEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassFocusOutEventFieldCallback)

-- | Set the value of the “<tt>focus_out_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #focusOutEvent <a>:=</a> value ]
--   </pre>
setWidgetClassFocusOutEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassFocusOutEventFieldCallback -> m ()

-- | Set the value of the “<tt>focus_out_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #focusOutEvent
--   </pre>
clearWidgetClassFocusOutEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>map_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #mapEvent
--   </pre>
getWidgetClassMapEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassMapEventFieldCallback)

-- | Set the value of the “<tt>map_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #mapEvent <a>:=</a> value ]
--   </pre>
setWidgetClassMapEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassMapEventFieldCallback -> m ()

-- | Set the value of the “<tt>map_event</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #mapEvent
--   </pre>
clearWidgetClassMapEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>unmap_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #unmapEvent
--   </pre>
getWidgetClassUnmapEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassUnmapEventFieldCallback)

-- | Set the value of the “<tt>unmap_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #unmapEvent <a>:=</a> value ]
--   </pre>
setWidgetClassUnmapEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassUnmapEventFieldCallback -> m ()

-- | Set the value of the “<tt>unmap_event</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #unmapEvent
--   </pre>
clearWidgetClassUnmapEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>property_notify_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #propertyNotifyEvent
--   </pre>
getWidgetClassPropertyNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassPropertyNotifyEventFieldCallback)

-- | Set the value of the “<tt>property_notify_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #propertyNotifyEvent <a>:=</a> value ]
--   </pre>
setWidgetClassPropertyNotifyEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassPropertyNotifyEventFieldCallback -> m ()

-- | Set the value of the “<tt>property_notify_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #propertyNotifyEvent
--   </pre>
clearWidgetClassPropertyNotifyEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>selection_clear_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #selectionClearEvent
--   </pre>
getWidgetClassSelectionClearEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassSelectionClearEventFieldCallback)

-- | Set the value of the “<tt>selection_clear_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #selectionClearEvent <a>:=</a> value ]
--   </pre>
setWidgetClassSelectionClearEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassSelectionClearEventFieldCallback -> m ()

-- | Set the value of the “<tt>selection_clear_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #selectionClearEvent
--   </pre>
clearWidgetClassSelectionClearEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>selection_request_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #selectionRequestEvent
--   </pre>
getWidgetClassSelectionRequestEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassSelectionRequestEventFieldCallback)

-- | Set the value of the “<tt>selection_request_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #selectionRequestEvent <a>:=</a> value ]
--   </pre>
setWidgetClassSelectionRequestEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassSelectionRequestEventFieldCallback -> m ()

-- | Set the value of the “<tt>selection_request_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #selectionRequestEvent
--   </pre>
clearWidgetClassSelectionRequestEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>selection_notify_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #selectionNotifyEvent
--   </pre>
getWidgetClassSelectionNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassSelectionNotifyEventFieldCallback)

-- | Set the value of the “<tt>selection_notify_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #selectionNotifyEvent <a>:=</a> value ]
--   </pre>
setWidgetClassSelectionNotifyEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassSelectionNotifyEventFieldCallback -> m ()

-- | Set the value of the “<tt>selection_notify_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #selectionNotifyEvent
--   </pre>
clearWidgetClassSelectionNotifyEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>proximity_in_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #proximityInEvent
--   </pre>
getWidgetClassProximityInEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassProximityInEventFieldCallback)

-- | Set the value of the “<tt>proximity_in_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #proximityInEvent <a>:=</a> value ]
--   </pre>
setWidgetClassProximityInEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassProximityInEventFieldCallback -> m ()

-- | Set the value of the “<tt>proximity_in_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #proximityInEvent
--   </pre>
clearWidgetClassProximityInEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>proximity_out_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #proximityOutEvent
--   </pre>
getWidgetClassProximityOutEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassProximityOutEventFieldCallback)

-- | Set the value of the “<tt>proximity_out_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #proximityOutEvent <a>:=</a> value ]
--   </pre>
setWidgetClassProximityOutEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassProximityOutEventFieldCallback -> m ()

-- | Set the value of the “<tt>proximity_out_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #proximityOutEvent
--   </pre>
clearWidgetClassProximityOutEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>visibility_notify_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #visibilityNotifyEvent
--   </pre>
getWidgetClassVisibilityNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassVisibilityNotifyEventFieldCallback)

-- | Set the value of the “<tt>visibility_notify_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #visibilityNotifyEvent <a>:=</a> value ]
--   </pre>
setWidgetClassVisibilityNotifyEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback -> m ()

-- | Set the value of the “<tt>visibility_notify_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #visibilityNotifyEvent
--   </pre>
clearWidgetClassVisibilityNotifyEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>window_state_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #windowStateEvent
--   </pre>
getWidgetClassWindowStateEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassWindowStateEventFieldCallback)

-- | Set the value of the “<tt>window_state_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #windowStateEvent <a>:=</a> value ]
--   </pre>
setWidgetClassWindowStateEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassWindowStateEventFieldCallback -> m ()

-- | Set the value of the “<tt>window_state_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #windowStateEvent
--   </pre>
clearWidgetClassWindowStateEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>damage_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #damageEvent
--   </pre>
getWidgetClassDamageEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDamageEventFieldCallback)

-- | Set the value of the “<tt>damage_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #damageEvent <a>:=</a> value ]
--   </pre>
setWidgetClassDamageEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDamageEventFieldCallback -> m ()

-- | Set the value of the “<tt>damage_event</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #damageEvent
--   </pre>
clearWidgetClassDamageEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>grab_broken_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #grabBrokenEvent
--   </pre>
getWidgetClassGrabBrokenEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGrabBrokenEventFieldCallback)

-- | Set the value of the “<tt>grab_broken_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #grabBrokenEvent <a>:=</a> value ]
--   </pre>
setWidgetClassGrabBrokenEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGrabBrokenEventFieldCallback -> m ()

-- | Set the value of the “<tt>grab_broken_event</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #grabBrokenEvent
--   </pre>
clearWidgetClassGrabBrokenEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>selection_get</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #selectionGet
--   </pre>
getWidgetClassSelectionGet :: MonadIO m => WidgetClass -> m (Maybe WidgetClassSelectionGetFieldCallback)

-- | Set the value of the “<tt>selection_get</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #selectionGet <a>:=</a> value ]
--   </pre>
setWidgetClassSelectionGet :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassSelectionGetFieldCallback -> m ()

-- | Set the value of the “<tt>selection_get</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #selectionGet
--   </pre>
clearWidgetClassSelectionGet :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>selection_received</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #selectionReceived
--   </pre>
getWidgetClassSelectionReceived :: MonadIO m => WidgetClass -> m (Maybe WidgetClassSelectionReceivedFieldCallback)

-- | Set the value of the “<tt>selection_received</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #selectionReceived <a>:=</a> value ]
--   </pre>
setWidgetClassSelectionReceived :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassSelectionReceivedFieldCallback -> m ()

-- | Set the value of the “<tt>selection_received</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #selectionReceived
--   </pre>
clearWidgetClassSelectionReceived :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>drag_begin</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #dragBegin
--   </pre>
getWidgetClassDragBegin :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragBeginFieldCallback)

-- | Set the value of the “<tt>drag_begin</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #dragBegin <a>:=</a> value ]
--   </pre>
setWidgetClassDragBegin :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragBeginFieldCallback -> m ()

-- | Set the value of the “<tt>drag_begin</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #dragBegin
--   </pre>
clearWidgetClassDragBegin :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>drag_end</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #dragEnd
--   </pre>
getWidgetClassDragEnd :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragEndFieldCallback)

-- | Set the value of the “<tt>drag_end</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #dragEnd <a>:=</a> value ]
--   </pre>
setWidgetClassDragEnd :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragEndFieldCallback -> m ()

-- | Set the value of the “<tt>drag_end</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #dragEnd
--   </pre>
clearWidgetClassDragEnd :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>drag_data_get</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #dragDataGet
--   </pre>
getWidgetClassDragDataGet :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragDataGetFieldCallback)

-- | Set the value of the “<tt>drag_data_get</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #dragDataGet <a>:=</a> value ]
--   </pre>
setWidgetClassDragDataGet :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragDataGetFieldCallback -> m ()

-- | Set the value of the “<tt>drag_data_get</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #dragDataGet
--   </pre>
clearWidgetClassDragDataGet :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>drag_data_delete</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #dragDataDelete
--   </pre>
getWidgetClassDragDataDelete :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragDataDeleteFieldCallback)

-- | Set the value of the “<tt>drag_data_delete</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #dragDataDelete <a>:=</a> value ]
--   </pre>
setWidgetClassDragDataDelete :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragDataDeleteFieldCallback -> m ()

-- | Set the value of the “<tt>drag_data_delete</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #dragDataDelete
--   </pre>
clearWidgetClassDragDataDelete :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>drag_leave</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #dragLeave
--   </pre>
getWidgetClassDragLeave :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragLeaveFieldCallback)

-- | Set the value of the “<tt>drag_leave</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #dragLeave <a>:=</a> value ]
--   </pre>
setWidgetClassDragLeave :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragLeaveFieldCallback -> m ()

-- | Set the value of the “<tt>drag_leave</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #dragLeave
--   </pre>
clearWidgetClassDragLeave :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>drag_motion</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #dragMotion
--   </pre>
getWidgetClassDragMotion :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragMotionFieldCallback)

-- | Set the value of the “<tt>drag_motion</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #dragMotion <a>:=</a> value ]
--   </pre>
setWidgetClassDragMotion :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragMotionFieldCallback -> m ()

-- | Set the value of the “<tt>drag_motion</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #dragMotion
--   </pre>
clearWidgetClassDragMotion :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>drag_drop</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #dragDrop
--   </pre>
getWidgetClassDragDrop :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragDropFieldCallback)

-- | Set the value of the “<tt>drag_drop</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #dragDrop <a>:=</a> value ]
--   </pre>
setWidgetClassDragDrop :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragDropFieldCallback -> m ()

-- | Set the value of the “<tt>drag_drop</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #dragDrop
--   </pre>
clearWidgetClassDragDrop :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>drag_data_received</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #dragDataReceived
--   </pre>
getWidgetClassDragDataReceived :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragDataReceivedFieldCallback)

-- | Set the value of the “<tt>drag_data_received</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #dragDataReceived <a>:=</a> value ]
--   </pre>
setWidgetClassDragDataReceived :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragDataReceivedFieldCallback -> m ()

-- | Set the value of the “<tt>drag_data_received</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #dragDataReceived
--   </pre>
clearWidgetClassDragDataReceived :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>drag_failed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #dragFailed
--   </pre>
getWidgetClassDragFailed :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDragFailedFieldCallback)

-- | Set the value of the “<tt>drag_failed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #dragFailed <a>:=</a> value ]
--   </pre>
setWidgetClassDragFailed :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDragFailedFieldCallback -> m ()

-- | Set the value of the “<tt>drag_failed</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #dragFailed
--   </pre>
clearWidgetClassDragFailed :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>popup_menu</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #popupMenu
--   </pre>
getWidgetClassPopupMenu :: MonadIO m => WidgetClass -> m (Maybe WidgetClassPopupMenuFieldCallback)

-- | Set the value of the “<tt>popup_menu</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #popupMenu <a>:=</a> value ]
--   </pre>
setWidgetClassPopupMenu :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassPopupMenuFieldCallback -> m ()

-- | Set the value of the “<tt>popup_menu</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #popupMenu
--   </pre>
clearWidgetClassPopupMenu :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>show_help</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #showHelp
--   </pre>
getWidgetClassShowHelp :: MonadIO m => WidgetClass -> m (Maybe WidgetClassShowHelpFieldCallback)

-- | Set the value of the “<tt>show_help</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #showHelp <a>:=</a> value ]
--   </pre>
setWidgetClassShowHelp :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassShowHelpFieldCallback -> m ()

-- | Set the value of the “<tt>show_help</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #showHelp
--   </pre>
clearWidgetClassShowHelp :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>get_accessible</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #getAccessible
--   </pre>
getWidgetClassGetAccessible :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGetAccessibleFieldCallback)

-- | Set the value of the “<tt>get_accessible</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #getAccessible <a>:=</a> value ]
--   </pre>
setWidgetClassGetAccessible :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGetAccessibleFieldCallback -> m ()

-- | Set the value of the “<tt>get_accessible</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #getAccessible
--   </pre>
clearWidgetClassGetAccessible :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>screen_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #screenChanged
--   </pre>
getWidgetClassScreenChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassScreenChangedFieldCallback)

-- | Set the value of the “<tt>screen_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #screenChanged <a>:=</a> value ]
--   </pre>
setWidgetClassScreenChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassScreenChangedFieldCallback -> m ()

-- | Set the value of the “<tt>screen_changed</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #screenChanged
--   </pre>
clearWidgetClassScreenChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>can_activate_accel</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #canActivateAccel
--   </pre>
getWidgetClassCanActivateAccel :: MonadIO m => WidgetClass -> m (Maybe WidgetClassCanActivateAccelFieldCallback)

-- | Set the value of the “<tt>can_activate_accel</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #canActivateAccel <a>:=</a> value ]
--   </pre>
setWidgetClassCanActivateAccel :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassCanActivateAccelFieldCallback -> m ()

-- | Set the value of the “<tt>can_activate_accel</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #canActivateAccel
--   </pre>
clearWidgetClassCanActivateAccel :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>composited_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #compositedChanged
--   </pre>
getWidgetClassCompositedChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassCompositedChangedFieldCallback)

-- | Set the value of the “<tt>composited_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #compositedChanged <a>:=</a> value ]
--   </pre>
setWidgetClassCompositedChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassCompositedChangedFieldCallback -> m ()

-- | Set the value of the “<tt>composited_changed</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #compositedChanged
--   </pre>
clearWidgetClassCompositedChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>query_tooltip</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #queryTooltip
--   </pre>
getWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> m (Maybe WidgetClassQueryTooltipFieldCallback)

-- | Set the value of the “<tt>query_tooltip</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #queryTooltip <a>:=</a> value ]
--   </pre>
setWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassQueryTooltipFieldCallback -> m ()

-- | Set the value of the “<tt>query_tooltip</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #queryTooltip
--   </pre>
clearWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>compute_expand</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #computeExpand
--   </pre>
getWidgetClassComputeExpand :: MonadIO m => WidgetClass -> m (Maybe WidgetClassComputeExpandFieldCallback)

-- | Set the value of the “<tt>compute_expand</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #computeExpand <a>:=</a> value ]
--   </pre>
setWidgetClassComputeExpand :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassComputeExpandFieldCallback -> m ()

-- | Set the value of the “<tt>compute_expand</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #computeExpand
--   </pre>
clearWidgetClassComputeExpand :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>adjust_size_request</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #adjustSizeRequest
--   </pre>
getWidgetClassAdjustSizeRequest :: MonadIO m => WidgetClass -> m (Maybe WidgetClassAdjustSizeRequestFieldCallback)

-- | Set the value of the “<tt>adjust_size_request</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #adjustSizeRequest <a>:=</a> value ]
--   </pre>
setWidgetClassAdjustSizeRequest :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassAdjustSizeRequestFieldCallback -> m ()

-- | Set the value of the “<tt>adjust_size_request</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #adjustSizeRequest
--   </pre>
clearWidgetClassAdjustSizeRequest :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>adjust_size_allocation</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #adjustSizeAllocation
--   </pre>
getWidgetClassAdjustSizeAllocation :: MonadIO m => WidgetClass -> m (Maybe WidgetClassAdjustSizeAllocationFieldCallback)

-- | Set the value of the “<tt>adjust_size_allocation</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #adjustSizeAllocation <a>:=</a> value ]
--   </pre>
setWidgetClassAdjustSizeAllocation :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback -> m ()

-- | Set the value of the “<tt>adjust_size_allocation</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #adjustSizeAllocation
--   </pre>
clearWidgetClassAdjustSizeAllocation :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>style_updated</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #styleUpdated
--   </pre>
getWidgetClassStyleUpdated :: MonadIO m => WidgetClass -> m (Maybe WidgetClassStyleUpdatedFieldCallback)

-- | Set the value of the “<tt>style_updated</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #styleUpdated <a>:=</a> value ]
--   </pre>
setWidgetClassStyleUpdated :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassStyleUpdatedFieldCallback -> m ()

-- | Set the value of the “<tt>style_updated</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #styleUpdated
--   </pre>
clearWidgetClassStyleUpdated :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>touch_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #touchEvent
--   </pre>
getWidgetClassTouchEvent :: MonadIO m => WidgetClass -> m (Maybe WidgetClassTouchEventFieldCallback)

-- | Set the value of the “<tt>touch_event</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #touchEvent <a>:=</a> value ]
--   </pre>
setWidgetClassTouchEvent :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassTouchEventFieldCallback -> m ()

-- | Set the value of the “<tt>touch_event</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #touchEvent
--   </pre>
clearWidgetClassTouchEvent :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the
--   “<tt>get_preferred_height_and_baseline_for_width</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #getPreferredHeightAndBaselineForWidth
--   </pre>
getWidgetClassGetPreferredHeightAndBaselineForWidth :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)

-- | Set the value of the
--   “<tt>get_preferred_height_and_baseline_for_width</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #getPreferredHeightAndBaselineForWidth <a>:=</a> value ]
--   </pre>
setWidgetClassGetPreferredHeightAndBaselineForWidth :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> m ()

-- | Set the value of the
--   “<tt>get_preferred_height_and_baseline_for_width</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #getPreferredHeightAndBaselineForWidth
--   </pre>
clearWidgetClassGetPreferredHeightAndBaselineForWidth :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>adjust_baseline_request</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #adjustBaselineRequest
--   </pre>
getWidgetClassAdjustBaselineRequest :: MonadIO m => WidgetClass -> m (Maybe WidgetClassAdjustBaselineRequestFieldCallback)

-- | Set the value of the “<tt>adjust_baseline_request</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #adjustBaselineRequest <a>:=</a> value ]
--   </pre>
setWidgetClassAdjustBaselineRequest :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback -> m ()

-- | Set the value of the “<tt>adjust_baseline_request</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #adjustBaselineRequest
--   </pre>
clearWidgetClassAdjustBaselineRequest :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>adjust_baseline_allocation</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #adjustBaselineAllocation
--   </pre>
getWidgetClassAdjustBaselineAllocation :: MonadIO m => WidgetClass -> m (Maybe WidgetClassAdjustBaselineAllocationFieldCallback)

-- | Set the value of the “<tt>adjust_baseline_allocation</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #adjustBaselineAllocation <a>:=</a> value ]
--   </pre>
setWidgetClassAdjustBaselineAllocation :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback -> m ()

-- | Set the value of the “<tt>adjust_baseline_allocation</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #adjustBaselineAllocation
--   </pre>
clearWidgetClassAdjustBaselineAllocation :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>queue_draw_region</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #queueDrawRegion
--   </pre>
getWidgetClassQueueDrawRegion :: MonadIO m => WidgetClass -> m (Maybe WidgetClassQueueDrawRegionFieldCallback)

-- | Set the value of the “<tt>queue_draw_region</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #queueDrawRegion <a>:=</a> value ]
--   </pre>
setWidgetClassQueueDrawRegion :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassQueueDrawRegionFieldCallback -> m ()

-- | Set the value of the “<tt>queue_draw_region</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #queueDrawRegion
--   </pre>
clearWidgetClassQueueDrawRegion :: MonadIO m => WidgetClass -> m ()

-- | Declares a <i><tt>callbackSymbol</tt></i> to handle
--   <i><tt>callbackName</tt></i> from the template XML defined for
--   <i><tt>widgetType</tt></i>. See <a>builderAddCallbackSymbol</a>.
--   
--   Note that this must be called from a composite widget classes class
--   initializer after calling <a>widgetClassSetTemplate</a>.
--   
--   <i>Since: 3.10</i>
widgetClassBindTemplateCallbackFull :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> Callback -> m ()

-- | Finds a style property of a widget class by name.
--   
--   <i>Since: 2.2</i>
widgetClassFindStyleProperty :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> m GParamSpec

-- | Gets the name used by this class for matching in CSS code. See
--   <a>widgetClassSetCssName</a> for details.
--   
--   <i>Since: 3.20</i>
widgetClassGetCssName :: (HasCallStack, MonadIO m) => WidgetClass -> m Text

-- | Installs a style property on a widget class. The parser for the style
--   property is determined by the value type of <i><tt>pspec</tt></i>.
widgetClassInstallStyleProperty :: (HasCallStack, MonadIO m) => WidgetClass -> GParamSpec -> m ()

-- | Sets the default <a>Role</a> to be set on accessibles created for
--   widgets of <i><tt>widgetClass</tt></i>. Accessibles may decide to not
--   honor this setting if their role reporting is more refined. Calls to
--   <a>widgetClassSetAccessibleType</a> will reset this value.
--   
--   In cases where you want more fine-grained control over the role of
--   accessibles created for <i><tt>widgetClass</tt></i>, you should
--   provide your own accessible type and use
--   <a>widgetClassSetAccessibleType</a> instead.
--   
--   If <i><tt>role</tt></i> is <tt><i>ATK_ROLE_INVALID</i></tt>, the
--   default role will not be changed and the accessible’s default role
--   will be used instead.
--   
--   This function should only be called from class init functions of
--   widgets.
--   
--   <i>Since: 3.2</i>
widgetClassSetAccessibleRole :: (HasCallStack, MonadIO m) => WidgetClass -> Role -> m ()

-- | Sets the type to be used for creating accessibles for widgets of
--   <i><tt>widgetClass</tt></i>. The given <i><tt>type</tt></i> must be a
--   subtype of the type used for accessibles of the parent class.
--   
--   This function should only be called from class init functions of
--   widgets.
--   
--   <i>Since: 3.2</i>
widgetClassSetAccessibleType :: (HasCallStack, MonadIO m) => WidgetClass -> GType -> m ()

-- | For use in language bindings, this will override the default
--   <a>BuilderConnectFunc</a> to be used when parsing GtkBuilder XML from
--   this class’s template data.
--   
--   Note that this must be called from a composite widget classes class
--   initializer after calling <a>widgetClassSetTemplate</a>.
--   
--   <i>Since: 3.10</i>
widgetClassSetConnectFunc :: (HasCallStack, MonadIO m) => WidgetClass -> BuilderConnectFunc -> m ()

-- | Sets the name to be used for CSS matching of widgets.
--   
--   If this function is not called for a given class, the name of the
--   parent class is used.
--   
--   <i>Since: 3.20</i>
widgetClassSetCssName :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> m ()

-- | A convenience function to call <a>widgetClassSetTemplate</a>.
--   
--   Note that any class that installs templates must call
--   <a>widgetInitTemplate</a> in the widget’s instance initializer.
--   
--   <i>Since: 3.10</i>
widgetClassSetTemplateFromResource :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> m ()

-- | Construct a <a>ContainerClass</a> struct initialized to zero.
newZeroContainerClass :: MonadIO m => m ContainerClass

-- | Get the value of the “<tt>parent_class</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> containerClass #parentClass
--   </pre>
getContainerClassParentClass :: MonadIO m => ContainerClass -> m WidgetClass

-- | Get the value of the “<tt>add</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> containerClass #add
--   </pre>
getContainerClassAdd :: MonadIO m => ContainerClass -> m (Maybe ContainerClassAddFieldCallback)

-- | Set the value of the “<tt>add</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> containerClass [ #add <a>:=</a> value ]
--   </pre>
setContainerClassAdd :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassAddFieldCallback -> m ()

-- | Set the value of the “<tt>add</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #add
--   </pre>
clearContainerClassAdd :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “<tt>remove</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> containerClass #remove
--   </pre>
getContainerClassRemove :: MonadIO m => ContainerClass -> m (Maybe ContainerClassRemoveFieldCallback)

-- | Set the value of the “<tt>remove</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> containerClass [ #remove <a>:=</a> value ]
--   </pre>
setContainerClassRemove :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassRemoveFieldCallback -> m ()

-- | Set the value of the “<tt>remove</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #remove
--   </pre>
clearContainerClassRemove :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “<tt>check_resize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> containerClass #checkResize
--   </pre>
getContainerClassCheckResize :: MonadIO m => ContainerClass -> m (Maybe ContainerClassCheckResizeFieldCallback)

-- | Set the value of the “<tt>check_resize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> containerClass [ #checkResize <a>:=</a> value ]
--   </pre>
setContainerClassCheckResize :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassCheckResizeFieldCallback -> m ()

-- | Set the value of the “<tt>check_resize</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #checkResize
--   </pre>
clearContainerClassCheckResize :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “<tt>forall</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> containerClass #forall
--   </pre>
getContainerClassForall :: MonadIO m => ContainerClass -> m (Maybe ContainerClassForallFieldCallback_WithClosures)

-- | Set the value of the “<tt>forall</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> containerClass [ #forall <a>:=</a> value ]
--   </pre>
setContainerClassForall :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassForallFieldCallback -> m ()

-- | Set the value of the “<tt>forall</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #forall
--   </pre>
clearContainerClassForall :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “<tt>set_focus_child</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> containerClass #setFocusChild
--   </pre>
getContainerClassSetFocusChild :: MonadIO m => ContainerClass -> m (Maybe ContainerClassSetFocusChildFieldCallback)

-- | Set the value of the “<tt>set_focus_child</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> containerClass [ #setFocusChild <a>:=</a> value ]
--   </pre>
setContainerClassSetFocusChild :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassSetFocusChildFieldCallback -> m ()

-- | Set the value of the “<tt>set_focus_child</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #setFocusChild
--   </pre>
clearContainerClassSetFocusChild :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “<tt>child_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> containerClass #childType
--   </pre>
getContainerClassChildType :: MonadIO m => ContainerClass -> m (Maybe ContainerClassChildTypeFieldCallback)

-- | Set the value of the “<tt>child_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> containerClass [ #childType <a>:=</a> value ]
--   </pre>
setContainerClassChildType :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassChildTypeFieldCallback -> m ()

-- | Set the value of the “<tt>child_type</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #childType
--   </pre>
clearContainerClassChildType :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “<tt>composite_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> containerClass #compositeName
--   </pre>
getContainerClassCompositeName :: MonadIO m => ContainerClass -> m (Maybe ContainerClassCompositeNameFieldCallback)

-- | Set the value of the “<tt>composite_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> containerClass [ #compositeName <a>:=</a> value ]
--   </pre>
setContainerClassCompositeName :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassCompositeNameFieldCallback -> m ()

-- | Set the value of the “<tt>composite_name</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #compositeName
--   </pre>
clearContainerClassCompositeName :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “<tt>set_child_property</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> containerClass #setChildProperty
--   </pre>
getContainerClassSetChildProperty :: MonadIO m => ContainerClass -> m (Maybe ContainerClassSetChildPropertyFieldCallback)

-- | Set the value of the “<tt>set_child_property</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> containerClass [ #setChildProperty <a>:=</a> value ]
--   </pre>
setContainerClassSetChildProperty :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassSetChildPropertyFieldCallback -> m ()

-- | Set the value of the “<tt>set_child_property</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #setChildProperty
--   </pre>
clearContainerClassSetChildProperty :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “<tt>get_child_property</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> containerClass #getChildProperty
--   </pre>
getContainerClassGetChildProperty :: MonadIO m => ContainerClass -> m (Maybe ContainerClassGetChildPropertyFieldCallback)

-- | Set the value of the “<tt>get_child_property</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> containerClass [ #getChildProperty <a>:=</a> value ]
--   </pre>
setContainerClassGetChildProperty :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassGetChildPropertyFieldCallback -> m ()

-- | Set the value of the “<tt>get_child_property</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #getChildProperty
--   </pre>
clearContainerClassGetChildProperty :: MonadIO m => ContainerClass -> m ()

-- | Get the value of the “<tt>get_path_for_child</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> containerClass #getPathForChild
--   </pre>
getContainerClassGetPathForChild :: MonadIO m => ContainerClass -> m (Maybe ContainerClassGetPathForChildFieldCallback)

-- | Set the value of the “<tt>get_path_for_child</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> containerClass [ #getPathForChild <a>:=</a> value ]
--   </pre>
setContainerClassGetPathForChild :: MonadIO m => ContainerClass -> FunPtr C_ContainerClassGetPathForChildFieldCallback -> m ()

-- | Set the value of the “<tt>get_path_for_child</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #getPathForChild
--   </pre>
clearContainerClassGetPathForChild :: MonadIO m => ContainerClass -> m ()

-- | Finds a child property of a container class by name.
containerClassFindChildProperty :: (HasCallStack, MonadIO m) => ContainerClass -> Text -> m (Maybe GParamSpec)

-- | Modifies a subclass of <a>ContainerClass</a> to automatically add and
--   remove the border-width setting on GtkContainer. This allows the
--   subclass to ignore the border width in its size request and allocate
--   methods. The intent is for a subclass to invoke this in its class_init
--   function.
--   
--   <a>containerClassHandleBorderWidth</a> is necessary because it would
--   break API too badly to make this behavior the default. So subclasses
--   must “opt in” to the parent class handling border_width for them.
containerClassHandleBorderWidth :: (HasCallStack, MonadIO m) => ContainerClass -> m ()

-- | Installs a child property on a container class.
containerClassInstallChildProperty :: (HasCallStack, MonadIO m) => ContainerClass -> Word32 -> GParamSpec -> m ()

-- | Construct a <a>ActionableInterface</a> struct initialized to zero.
newZeroActionableInterface :: MonadIO m => m ActionableInterface

-- | Get the value of the “<tt>get_action_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionableInterface #getActionName
--   </pre>
getActionableInterfaceGetActionName :: MonadIO m => ActionableInterface -> m (Maybe ActionableInterfaceGetActionNameFieldCallback)

-- | Set the value of the “<tt>get_action_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionableInterface [ #getActionName <a>:=</a> value ]
--   </pre>
setActionableInterfaceGetActionName :: MonadIO m => ActionableInterface -> FunPtr C_ActionableInterfaceGetActionNameFieldCallback -> m ()

-- | Set the value of the “<tt>get_action_name</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #getActionName
--   </pre>
clearActionableInterfaceGetActionName :: MonadIO m => ActionableInterface -> m ()

-- | Get the value of the “<tt>set_action_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionableInterface #setActionName
--   </pre>
getActionableInterfaceSetActionName :: MonadIO m => ActionableInterface -> m (Maybe ActionableInterfaceSetActionNameFieldCallback)

-- | Set the value of the “<tt>set_action_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionableInterface [ #setActionName <a>:=</a> value ]
--   </pre>
setActionableInterfaceSetActionName :: MonadIO m => ActionableInterface -> FunPtr C_ActionableInterfaceSetActionNameFieldCallback -> m ()

-- | Set the value of the “<tt>set_action_name</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #setActionName
--   </pre>
clearActionableInterfaceSetActionName :: MonadIO m => ActionableInterface -> m ()

-- | Get the value of the “<tt>get_action_target_value</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionableInterface #getActionTargetValue
--   </pre>
getActionableInterfaceGetActionTargetValue :: MonadIO m => ActionableInterface -> m (Maybe ActionableInterfaceGetActionTargetValueFieldCallback)

-- | Set the value of the “<tt>get_action_target_value</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionableInterface [ #getActionTargetValue <a>:=</a> value ]
--   </pre>
setActionableInterfaceGetActionTargetValue :: MonadIO m => ActionableInterface -> FunPtr C_ActionableInterfaceGetActionTargetValueFieldCallback -> m ()

-- | Set the value of the “<tt>get_action_target_value</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #getActionTargetValue
--   </pre>
clearActionableInterfaceGetActionTargetValue :: MonadIO m => ActionableInterface -> m ()

-- | Get the value of the “<tt>set_action_target_value</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionableInterface #setActionTargetValue
--   </pre>
getActionableInterfaceSetActionTargetValue :: MonadIO m => ActionableInterface -> m (Maybe ActionableInterfaceSetActionTargetValueFieldCallback)

-- | Set the value of the “<tt>set_action_target_value</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionableInterface [ #setActionTargetValue <a>:=</a> value ]
--   </pre>
setActionableInterfaceSetActionTargetValue :: MonadIO m => ActionableInterface -> FunPtr C_ActionableInterfaceSetActionTargetValueFieldCallback -> m ()

-- | Set the value of the “<tt>set_action_target_value</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #setActionTargetValue
--   </pre>
clearActionableInterfaceSetActionTargetValue :: MonadIO m => ActionableInterface -> m ()

-- | Cast to <a>PrintSettings</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPrintSettings :: (MonadIO m, IsPrintSettings o) => o -> m PrintSettings

-- | Creates a new <a>PrintSettings</a> object.
--   
--   <i>Since: 2.10</i>
printSettingsNew :: (HasCallStack, MonadIO m) => m PrintSettings

-- | Reads the print settings from <i><tt>fileName</tt></i>. Returns a new
--   <a>PrintSettings</a> object with the restored settings, or
--   <a>Nothing</a> if an error occurred. If the file could not be loaded
--   then error is set to either a <a>FileError</a> or <a>KeyFileError</a>.
--   See <a>printSettingsToFile</a>.
--   
--   <i>Since: 2.12</i>
printSettingsNewFromFile :: (HasCallStack, MonadIO m) => [Char] -> m PrintSettings

-- | Deserialize print settings from an a{sv} variant in the format
--   produced by <a>printSettingsToGvariant</a>.
--   
--   <i>Since: 3.22</i>
printSettingsNewFromGvariant :: (HasCallStack, MonadIO m) => GVariant -> m PrintSettings

-- | Reads the print settings from the group <i><tt>groupName</tt></i> in
--   <i><tt>keyFile</tt></i>. Returns a new <a>PrintSettings</a> object
--   with the restored settings, or <a>Nothing</a> if an error occurred. If
--   the file could not be loaded then error is set to either a
--   <a>FileError</a> or <a>KeyFileError</a>.
--   
--   <i>Since: 2.12</i>
printSettingsNewFromKeyFile :: (HasCallStack, MonadIO m) => KeyFile -> Maybe Text -> m PrintSettings

-- | Copies a <a>PrintSettings</a> object.
--   
--   <i>Since: 2.10</i>
printSettingsCopy :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PrintSettings

-- | Calls <i><tt>func</tt></i> for each key-value pair of
--   <i><tt>settings</tt></i>.
--   
--   <i>Since: 2.10</i>
printSettingsForeach :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PrintSettingsFunc -> m ()

-- | Looks up the string value associated with <i><tt>key</tt></i>.
--   
--   <i>Since: 2.10</i>
printSettingsGet :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m Text

-- | Returns the boolean represented by the value that is associated with
--   <i><tt>key</tt></i>.
--   
--   The string “true” represents <a>True</a>, any other string
--   <a>False</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetBool :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m Bool

-- | Gets the value of <a>PRINT_SETTINGS_COLLATE</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetCollate :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Bool

-- | Gets the value of <a>PRINT_SETTINGS_DEFAULT_SOURCE</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetDefaultSource :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Text

-- | Gets the value of <a>PRINT_SETTINGS_DITHER</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetDither :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Text

-- | Returns the double value associated with <i><tt>key</tt></i>, or 0.
--   
--   <i>Since: 2.10</i>
printSettingsGetDouble :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m Double

-- | Returns the floating point number represented by the value that is
--   associated with <i><tt>key</tt></i>, or <i><tt>defaultVal</tt></i> if
--   the value does not represent a floating point number.
--   
--   Floating point numbers are parsed with <a>asciiStrtod</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetDoubleWithDefault :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Double -> m Double

-- | Gets the value of <a>PRINT_SETTINGS_DUPLEX</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetDuplex :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PrintDuplex

-- | Gets the value of <a>PRINT_SETTINGS_FINISHINGS</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetFinishings :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Text

-- | Returns the integer value of <i><tt>key</tt></i>, or 0.
--   
--   <i>Since: 2.10</i>
printSettingsGetInt :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m Int32

-- | Returns the value of <i><tt>key</tt></i>, interpreted as an integer,
--   or the default value.
--   
--   <i>Since: 2.10</i>
printSettingsGetIntWithDefault :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Int32 -> m Int32

-- | Returns the value associated with <i><tt>key</tt></i>, interpreted as
--   a length. The returned value is converted to <i><tt>units</tt></i>.
--   
--   <i>Since: 2.10</i>
printSettingsGetLength :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Unit -> m Double

-- | Gets the value of <a>PRINT_SETTINGS_MEDIA_TYPE</a>.
--   
--   The set of media types is defined in PWG 5101.1-2002 PWG.
--   
--   <i>Since: 2.10</i>
printSettingsGetMediaType :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Text

-- | Gets the value of <a>PRINT_SETTINGS_N_COPIES</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetNCopies :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Int32

-- | Gets the value of <a>PRINT_SETTINGS_NUMBER_UP</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetNumberUp :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Int32

-- | Gets the value of <a>PRINT_SETTINGS_NUMBER_UP_LAYOUT</a>.
--   
--   <i>Since: 2.14</i>
printSettingsGetNumberUpLayout :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m NumberUpLayout

-- | Get the value of <a>PRINT_SETTINGS_ORIENTATION</a>, converted to a
--   <a>PageOrientation</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetOrientation :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PageOrientation

-- | Gets the value of <a>PRINT_SETTINGS_OUTPUT_BIN</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetOutputBin :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Text

-- | Gets the value of <a>PRINT_SETTINGS_PAGE_RANGES</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetPageRanges :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m [PageRange]

-- | Gets the value of <a>PRINT_SETTINGS_PAGE_SET</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetPageSet :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PageSet

-- | Gets the value of <a>PRINT_SETTINGS_PAPER_HEIGHT</a>, converted to
--   <i><tt>unit</tt></i>.
--   
--   <i>Since: 2.10</i>
printSettingsGetPaperHeight :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Unit -> m Double

-- | Gets the value of <a>PRINT_SETTINGS_PAPER_FORMAT</a>, converted to a
--   <a>PaperSize</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetPaperSize :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PaperSize

-- | Gets the value of <a>PRINT_SETTINGS_PAPER_WIDTH</a>, converted to
--   <i><tt>unit</tt></i>.
--   
--   <i>Since: 2.10</i>
printSettingsGetPaperWidth :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Unit -> m Double

-- | Gets the value of <a>PRINT_SETTINGS_PRINT_PAGES</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetPrintPages :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PrintPages

-- | Convenience function to obtain the value of
--   <a>PRINT_SETTINGS_PRINTER</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetPrinter :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Text

-- | Gets the value of <a>PRINT_SETTINGS_PRINTER_LPI</a>.
--   
--   <i>Since: 2.16</i>
printSettingsGetPrinterLpi :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Double

-- | Gets the value of <a>PRINT_SETTINGS_QUALITY</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetQuality :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PrintQuality

-- | Gets the value of <a>PRINT_SETTINGS_RESOLUTION</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetResolution :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Int32

-- | Gets the value of <a>PRINT_SETTINGS_RESOLUTION_X</a>.
--   
--   <i>Since: 2.16</i>
printSettingsGetResolutionX :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Int32

-- | Gets the value of <a>PRINT_SETTINGS_RESOLUTION_Y</a>.
--   
--   <i>Since: 2.16</i>
printSettingsGetResolutionY :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Int32

-- | Gets the value of <a>PRINT_SETTINGS_REVERSE</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetReverse :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Bool

-- | Gets the value of <a>PRINT_SETTINGS_SCALE</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetScale :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Double

-- | Gets the value of <a>PRINT_SETTINGS_USE_COLOR</a>.
--   
--   <i>Since: 2.10</i>
printSettingsGetUseColor :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Bool

-- | Returns <a>True</a>, if a value is associated with
--   <i><tt>key</tt></i>.
--   
--   <i>Since: 2.10</i>
printSettingsHasKey :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m Bool

-- | Reads the print settings from <i><tt>fileName</tt></i>. If the file
--   could not be loaded then error is set to either a <a>FileError</a> or
--   <a>KeyFileError</a>. See <a>printSettingsToFile</a>.
--   
--   <i>Since: 2.14</i>
printSettingsLoadFile :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> [Char] -> m ()

-- | Reads the print settings from the group <i><tt>groupName</tt></i> in
--   <i><tt>keyFile</tt></i>. If the file could not be loaded then error is
--   set to either a <a>FileError</a> or <a>KeyFileError</a>.
--   
--   <i>Since: 2.14</i>
printSettingsLoadKeyFile :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> KeyFile -> Maybe Text -> m ()

-- | Associates <i><tt>value</tt></i> with <i><tt>key</tt></i>.
--   
--   <i>Since: 2.10</i>
printSettingsSet :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Maybe Text -> m ()

-- | Sets <i><tt>key</tt></i> to a boolean value.
--   
--   <i>Since: 2.10</i>
printSettingsSetBool :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Bool -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_COLLATE</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetCollate :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Bool -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_DEFAULT_SOURCE</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetDefaultSource :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_DITHER</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetDither :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets <i><tt>key</tt></i> to a double value.
--   
--   <i>Since: 2.10</i>
printSettingsSetDouble :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Double -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_FINISHINGS</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetFinishings :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets <i><tt>key</tt></i> to an integer value.
--   
--   <i>Since: 2.10</i>
printSettingsSetInt :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Int32 -> m ()

-- | Associates a length in units of <i><tt>unit</tt></i> with
--   <i><tt>key</tt></i>.
--   
--   <i>Since: 2.10</i>
printSettingsSetLength :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Double -> Unit -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_MEDIA_TYPE</a>.
--   
--   The set of media types is defined in PWG 5101.1-2002 PWG.
--   
--   <i>Since: 2.10</i>
printSettingsSetMediaType :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_N_COPIES</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetNCopies :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Int32 -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_NUMBER_UP</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetNumberUp :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Int32 -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_NUMBER_UP_LAYOUT</a>.
--   
--   <i>Since: 2.14</i>
printSettingsSetNumberUpLayout :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> NumberUpLayout -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_OUTPUT_BIN</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetOutputBin :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_PAGE_RANGES</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetPageRanges :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> [PageRange] -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_PAGE_SET</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetPageSet :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PageSet -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_PAPER_HEIGHT</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetPaperHeight :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Double -> Unit -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_PAPER_FORMAT</a>,
--   <a>PRINT_SETTINGS_PAPER_WIDTH</a> and
--   <a>PRINT_SETTINGS_PAPER_HEIGHT</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetPaperSize :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PaperSize -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_PRINT_PAGES</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetPrintPages :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PrintPages -> m ()

-- | Convenience function to set <a>PRINT_SETTINGS_PRINTER</a> to
--   <i><tt>printer</tt></i>.
--   
--   <i>Since: 2.10</i>
printSettingsSetPrinter :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_PRINTER_LPI</a>.
--   
--   <i>Since: 2.16</i>
printSettingsSetPrinterLpi :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Double -> m ()

-- | Sets the values of <a>PRINT_SETTINGS_RESOLUTION</a>,
--   <a>PRINT_SETTINGS_RESOLUTION_X</a> and
--   <a>PRINT_SETTINGS_RESOLUTION_Y</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetResolution :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Int32 -> m ()

-- | Sets the values of <a>PRINT_SETTINGS_RESOLUTION</a>,
--   <a>PRINT_SETTINGS_RESOLUTION_X</a> and
--   <a>PRINT_SETTINGS_RESOLUTION_Y</a>.
--   
--   <i>Since: 2.16</i>
printSettingsSetResolutionXy :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Int32 -> Int32 -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_REVERSE</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetReverse :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Bool -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_SCALE</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetScale :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Double -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_USE_COLOR</a>.
--   
--   <i>Since: 2.10</i>
printSettingsSetUseColor :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Bool -> m ()

-- | This function saves the print settings from <i><tt>settings</tt></i>
--   to <i><tt>fileName</tt></i>. If the file could not be loaded then
--   error is set to either a <a>FileError</a> or <a>KeyFileError</a>.
--   
--   <i>Since: 2.12</i>
printSettingsToFile :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> [Char] -> m ()

-- | Serialize print settings to an a{sv} variant.
--   
--   <i>Since: 3.22</i>
printSettingsToGvariant :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m GVariant

-- | This function adds the print settings from <i><tt>settings</tt></i> to
--   <i><tt>keyFile</tt></i>.
--   
--   <i>Since: 2.12</i>
printSettingsToKeyFile :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> KeyFile -> Maybe Text -> m ()

-- | Removes any value associated with <i><tt>key</tt></i>. This has the
--   same effect as setting the value to <a>Nothing</a>.
--   
--   <i>Since: 2.10</i>
printSettingsUnset :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Cast to <a>AccelMap</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toAccelMap :: (MonadIO m, IsAccelMap o) => o -> m AccelMap

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> accelMap #changed callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to “<tt>changed::detail</tt>”
--   instead.
onAccelMapChanged :: (IsAccelMap a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AccelMapChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> accelMap #changed callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to “<tt>changed::detail</tt>”
--   instead.
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAccelMapChanged :: (IsAccelMap a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AccelMapChangedCallback) -> m SignalHandlerId

-- | Adds a filter to the global list of accel path filters.
--   
--   Accel map entries whose accel path matches one of the filters are
--   skipped by <a>accelMapForeach</a>.
--   
--   This function is intended for GTK+ modules that create their own
--   menus, but don’t want them to be saved into the applications
--   accelerator map dump.
accelMapAddFilter :: (HasCallStack, MonadIO m) => Text -> m ()

-- | Gets the singleton global <a>AccelMap</a> object. This object is
--   useful only for notification of changes to the accelerator map via the
--   <a>changed</a> signal; it isn’t a parameter to the other accelerator
--   map functions.
--   
--   <i>Since: 2.4</i>
accelMapGet :: (HasCallStack, MonadIO m) => m AccelMap

-- | Parses a file previously saved with <a>accelMapSave</a> for
--   accelerator specifications, and propagates them accordingly.
accelMapLoad :: (HasCallStack, MonadIO m) => [Char] -> m ()

-- | Filedescriptor variant of <a>accelMapLoad</a>.
--   
--   Note that the file descriptor will not be closed by this function.
accelMapLoadFd :: (HasCallStack, MonadIO m) => Int32 -> m ()

-- | <a>Scanner</a> variant of <a>accelMapLoad</a>.
accelMapLoadScanner :: (HasCallStack, MonadIO m) => Scanner -> m ()

-- | Locks the given accelerator path. If the accelerator map doesn’t yet
--   contain an entry for <i><tt>accelPath</tt></i>, a new one is created.
--   
--   Locking an accelerator path prevents its accelerator from being
--   changed during runtime. A locked accelerator path can be unlocked by
--   <a>accelMapUnlockPath</a>. Refer to <a>accelMapChangeEntry</a> for
--   information about runtime accelerator changes.
--   
--   If called more than once, <i><tt>accelPath</tt></i> remains locked
--   until <a>accelMapUnlockPath</a> has been called an equivalent number
--   of times.
--   
--   Note that locking of individual accelerator paths is independent from
--   locking the <a>AccelGroup</a> containing them. For runtime accelerator
--   changes to be possible, both the accelerator path and its
--   <a>AccelGroup</a> have to be unlocked.
--   
--   <i>Since: 2.4</i>
accelMapLockPath :: (HasCallStack, MonadIO m) => Text -> m ()

-- | Looks up the accelerator entry for <i><tt>accelPath</tt></i> and fills
--   in <i><tt>key</tt></i>.
accelMapLookupEntry :: (HasCallStack, MonadIO m) => Text -> m (Bool, AccelKey)

-- | Filedescriptor variant of <a>accelMapSave</a>.
--   
--   Note that the file descriptor will not be closed by this function.
accelMapSaveFd :: (HasCallStack, MonadIO m) => Int32 -> m ()

-- | Undoes the last call to <a>accelMapLockPath</a> on this
--   <i><tt>accelPath</tt></i>. Refer to <a>accelMapLockPath</a> for
--   information about accelerator path locking.
--   
--   <i>Since: 2.4</i>
accelMapUnlockPath :: (HasCallStack, MonadIO m) => Text -> m ()

-- | You do not need to use this function.
--   
--   Creates a row reference based on <i><tt>path</tt></i>.
--   
--   This reference will keep pointing to the node pointed to by
--   <i><tt>path</tt></i>, so long as it exists. If <i><tt>path</tt></i>
--   isn’t a valid path in <i><tt>model</tt></i>, then <a>Nothing</a> is
--   returned. However, unlike references created with
--   <a>treeRowReferenceNew</a>, it does not listen to the model for
--   changes. The creator of the row reference must do this explicitly
--   using <a>treeRowReferenceInserted</a>, <a>treeRowReferenceDeleted</a>,
--   <tt><i>gtk_tree_row_reference_reordered()</i></tt>.
--   
--   These functions must be called exactly once per proxy when the
--   corresponding signal on the model is emitted. This single call updates
--   all row references for that proxy. Since built-in GTK+ objects like
--   <a>TreeView</a> already use this mechanism internally, using them as
--   the proxy object will produce unpredictable results. Further more,
--   passing the same object as <i><tt>model</tt></i> and
--   <i><tt>proxy</tt></i> doesn’t work for reasons of internal
--   implementation.
--   
--   This type of row reference is primarily meant by structures that need
--   to carefully monitor exactly when a row reference updates itself, and
--   is not generally needed by most applications.
treeRowReferenceNewProxy :: (HasCallStack, MonadIO m, IsObject a, IsTreeModel b) => a -> b -> TreePath -> m TreeRowReference

-- | Copies a <a>TreeRowReference</a>.
--   
--   <i>Since: 2.2</i>
treeRowReferenceCopy :: (HasCallStack, MonadIO m) => TreeRowReference -> m TreeRowReference

-- | Free’s <i><tt>reference</tt></i>. <i><tt>reference</tt></i> may be
--   <a>Nothing</a>
treeRowReferenceFree :: (HasCallStack, MonadIO m) => Maybe TreeRowReference -> m ()

-- | Returns the model that the row reference is monitoring.
--   
--   <i>Since: 2.8</i>
treeRowReferenceGetModel :: (HasCallStack, MonadIO m) => TreeRowReference -> m TreeModel

-- | Returns a path that the row reference currently points to, or
--   <a>Nothing</a> if the path pointed to is no longer valid.
treeRowReferenceGetPath :: (HasCallStack, MonadIO m) => TreeRowReference -> m (Maybe TreePath)

-- | Returns <a>True</a> if the <i><tt>reference</tt></i> is
--   non-<a>Nothing</a> and refers to a current valid path.
treeRowReferenceValid :: (HasCallStack, MonadIO m) => Maybe TreeRowReference -> m Bool

-- | Cast to <a>TreeSortable</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeSortable :: (MonadIO m, IsTreeSortable o) => o -> m TreeSortable

-- | Fills in <i><tt>sortColumnId</tt></i> and <i><tt>order</tt></i> with
--   the current sort column and the order. It returns <a>True</a> unless
--   the <i><tt>sortColumnId</tt></i> is
--   <a>TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID</a> or
--   <a>TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID</a>.
treeSortableGetSortColumnId :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> m (Bool, Int32, SortType)

-- | Returns <a>True</a> if the model has a default sort function. This is
--   used primarily by GtkTreeViewColumns in order to determine if a model
--   can go back to the default state, or not.
treeSortableHasDefaultSortFunc :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> m Bool

-- | Sets the default comparison function used when sorting to be
--   <i><tt>sortFunc</tt></i>. If the current sort column id of
--   <i><tt>sortable</tt></i> is
--   <a>TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID</a>, then the model will sort
--   using this function.
--   
--   If <i><tt>sortFunc</tt></i> is <a>Nothing</a>, then there will be no
--   default comparison function. This means that once the model has been
--   sorted, it can’t go back to the default state. In this case, when the
--   current sort column id of <i><tt>sortable</tt></i> is
--   <a>TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID</a>, the model will be
--   unsorted.
treeSortableSetDefaultSortFunc :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> TreeIterCompareFunc -> m ()

-- | Emits a <a>TreeSortable::sortColumnChanged</a> signal on
--   <i><tt>sortable</tt></i>.
treeSortableSortColumnChanged :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> m ()

-- | Connect a signal handler for the <a>sortColumnChanged</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeSortable #sortColumnChanged callback
--   </pre>
onTreeSortableSortColumnChanged :: (IsTreeSortable a, MonadIO m) => a -> ((?self :: a) => TreeSortableSortColumnChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>sortColumnChanged</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeSortable #sortColumnChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeSortableSortColumnChanged :: (IsTreeSortable a, MonadIO m) => a -> ((?self :: a) => TreeSortableSortColumnChangedCallback) -> m SignalHandlerId

-- | Cast to <a>FontChooser</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFontChooser :: (MonadIO m, IsFontChooser o) => o -> m FontChooser

-- | Get the value of the “<tt>font</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontChooser #font
--   </pre>
getFontChooserFont :: (MonadIO m, IsFontChooser o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>font</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontChooser [ #font <a>:=</a> value ]
--   </pre>
setFontChooserFont :: (MonadIO m, IsFontChooser o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFontChooserFont :: (IsFontChooser o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>font-desc</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontChooser #fontDesc
--   </pre>
getFontChooserFontDesc :: (MonadIO m, IsFontChooser o) => o -> m (Maybe FontDescription)

-- | Set the value of the “<tt>font-desc</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontChooser [ #fontDesc <a>:=</a> value ]
--   </pre>
setFontChooserFontDesc :: (MonadIO m, IsFontChooser o) => o -> FontDescription -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font-desc</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontChooserFontDesc :: (IsFontChooser o, MonadIO m) => FontDescription -> m (GValueConstruct o)

-- | Get the value of the “<tt>font-features</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontChooser #fontFeatures
--   </pre>
getFontChooserFontFeatures :: (MonadIO m, IsFontChooser o) => o -> m (Maybe Text)

-- | Get the value of the “<tt>language</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontChooser #language
--   </pre>
getFontChooserLanguage :: (MonadIO m, IsFontChooser o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>language</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontChooser [ #language <a>:=</a> value ]
--   </pre>
setFontChooserLanguage :: (MonadIO m, IsFontChooser o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>language</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontChooserLanguage :: (IsFontChooser o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontChooser #level
--   </pre>
getFontChooserLevel :: (MonadIO m, IsFontChooser o) => o -> m [FontChooserLevel]

-- | Set the value of the “<tt>level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontChooser [ #level <a>:=</a> value ]
--   </pre>
setFontChooserLevel :: (MonadIO m, IsFontChooser o) => o -> [FontChooserLevel] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>level</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFontChooserLevel :: (IsFontChooser o, MonadIO m) => [FontChooserLevel] -> m (GValueConstruct o)

-- | Get the value of the “<tt>preview-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontChooser #previewText
--   </pre>
getFontChooserPreviewText :: (MonadIO m, IsFontChooser o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>preview-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontChooser [ #previewText <a>:=</a> value ]
--   </pre>
setFontChooserPreviewText :: (MonadIO m, IsFontChooser o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>preview-text</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFontChooserPreviewText :: (IsFontChooser o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-preview-entry</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontChooser #showPreviewEntry
--   </pre>
getFontChooserShowPreviewEntry :: (MonadIO m, IsFontChooser o) => o -> m Bool

-- | Set the value of the “<tt>show-preview-entry</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontChooser [ #showPreviewEntry <a>:=</a> value ]
--   </pre>
setFontChooserShowPreviewEntry :: (MonadIO m, IsFontChooser o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-preview-entry</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructFontChooserShowPreviewEntry :: (IsFontChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Gets the currently-selected font.
--   
--   Note that this can be a different string than what you set with
--   <a>fontChooserSetFont</a>, as the font chooser widget may normalize
--   font names and thus return a string with a different structure. For
--   example, “Helvetica Italic Bold 12” could be normalized to “Helvetica
--   Bold Italic 12”.
--   
--   Use <a>fontDescriptionEqual</a> if you want to compare two font
--   descriptions.
--   
--   <i>Since: 3.2</i>
fontChooserGetFontDesc :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m (Maybe FontDescription)

-- | Gets the <a>FontFace</a> representing the selected font group details
--   (i.e. family, slant, weight, width, etc).
--   
--   If the selected font is not installed, returns <a>Nothing</a>.
--   
--   <i>Since: 3.2</i>
fontChooserGetFontFace :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m (Maybe FontFace)

-- | Gets the <a>FontFamily</a> representing the selected font family. Font
--   families are a collection of font faces.
--   
--   If the selected font is not installed, returns <a>Nothing</a>.
--   
--   <i>Since: 3.2</i>
fontChooserGetFontFamily :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m (Maybe FontFamily)

-- | Gets the currently-selected font features.
--   
--   <i>Since: 3.24</i>
fontChooserGetFontFeatures :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Text

-- | Gets the custom font map of this font chooser widget, or
--   <a>Nothing</a> if it does not have one.
--   
--   <i>Since: 3.18</i>
fontChooserGetFontMap :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m (Maybe FontMap)

-- | The selected font size.
--   
--   <i>Since: 3.2</i>
fontChooserGetFontSize :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Int32

-- | Gets the language that is used for font features.
--   
--   <i>Since: 3.24</i>
fontChooserGetLanguage :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Text

-- | Returns the current level of granularity for selecting fonts.
--   
--   <i>Since: 3.24</i>
fontChooserGetLevel :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m [FontChooserLevel]

-- | Gets the text displayed in the preview area.
--   
--   <i>Since: 3.2</i>
fontChooserGetPreviewText :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Text

-- | Returns whether the preview entry is shown or not.
--   
--   <i>Since: 3.2</i>
fontChooserGetShowPreviewEntry :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Bool

-- | Sets the currently-selected font.
--   
--   <i>Since: 3.2</i>
fontChooserSetFont :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Text -> m ()

-- | Sets the currently-selected font from <i><tt>fontDesc</tt></i>.
--   
--   <i>Since: 3.2</i>
fontChooserSetFontDesc :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> FontDescription -> m ()

-- | Sets a custom font map to use for this font chooser widget. A custom
--   font map can be used to present application-specific fonts instead of
--   or in addition to the normal system fonts.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   FcConfig *config;
--   PangoFontMap *fontmap;
--   
--   config = FcInitLoadConfigAndFonts ();
--   FcConfigAppFontAddFile (config, my_app_font_file);
--   
--   fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
--   pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
--   
--   gtk_font_chooser_set_font_map (font_chooser, fontmap);
--   </pre>
--   
--   Note that other GTK+ widgets will only be able to use the
--   application-specific font if it is present in the font map they use:
--   
--   <pre>
--   context = gtk_widget_get_pango_context (label);
--   pango_context_set_font_map (context, fontmap);
--   </pre>
--   
--   <i>Since: 3.18</i>
fontChooserSetFontMap :: (HasCallStack, MonadIO m, IsFontChooser a, IsFontMap b) => a -> Maybe b -> m ()

-- | Sets the language to use for font features.
--   
--   <i>Since: 3.24</i>
fontChooserSetLanguage :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Text -> m ()

-- | Sets the desired level of granularity for selecting fonts.
--   
--   <i>Since: 3.24</i>
fontChooserSetLevel :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> [FontChooserLevel] -> m ()

-- | Sets the text displayed in the preview area. The <i><tt>text</tt></i>
--   is used to show how the selected font looks.
--   
--   <i>Since: 3.2</i>
fontChooserSetPreviewText :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Text -> m ()

-- | Shows or hides the editable preview entry.
--   
--   <i>Since: 3.2</i>
fontChooserSetShowPreviewEntry :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Bool -> m ()

-- | Connect a signal handler for the <a>fontActivated</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fontChooser #fontActivated callback
--   </pre>
onFontChooserFontActivated :: (IsFontChooser a, MonadIO m) => a -> ((?self :: a) => FontChooserFontActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>fontActivated</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fontChooser #fontActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFontChooserFontActivated :: (IsFontChooser a, MonadIO m) => a -> ((?self :: a) => FontChooserFontActivatedCallback) -> m SignalHandlerId

-- | Construct a <a>TableChild</a> struct initialized to zero.
newZeroTableChild :: MonadIO m => m TableChild

-- | Get the value of the “<tt>widget</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableChild #widget
--   </pre>
getTableChildWidget :: MonadIO m => TableChild -> m (Maybe Widget)

-- | Set the value of the “<tt>widget</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableChild [ #widget <a>:=</a> value ]
--   </pre>
setTableChildWidget :: MonadIO m => TableChild -> Ptr Widget -> m ()

-- | Set the value of the “<tt>widget</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #widget
--   </pre>
clearTableChildWidget :: MonadIO m => TableChild -> m ()

-- | Get the value of the “<tt>left_attach</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableChild #leftAttach
--   </pre>
getTableChildLeftAttach :: MonadIO m => TableChild -> m Word16

-- | Set the value of the “<tt>left_attach</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableChild [ #leftAttach <a>:=</a> value ]
--   </pre>
setTableChildLeftAttach :: MonadIO m => TableChild -> Word16 -> m ()

-- | Get the value of the “<tt>right_attach</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableChild #rightAttach
--   </pre>
getTableChildRightAttach :: MonadIO m => TableChild -> m Word16

-- | Set the value of the “<tt>right_attach</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableChild [ #rightAttach <a>:=</a> value ]
--   </pre>
setTableChildRightAttach :: MonadIO m => TableChild -> Word16 -> m ()

-- | Get the value of the “<tt>top_attach</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableChild #topAttach
--   </pre>
getTableChildTopAttach :: MonadIO m => TableChild -> m Word16

-- | Set the value of the “<tt>top_attach</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableChild [ #topAttach <a>:=</a> value ]
--   </pre>
setTableChildTopAttach :: MonadIO m => TableChild -> Word16 -> m ()

-- | Get the value of the “<tt>bottom_attach</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableChild #bottomAttach
--   </pre>
getTableChildBottomAttach :: MonadIO m => TableChild -> m Word16

-- | Set the value of the “<tt>bottom_attach</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableChild [ #bottomAttach <a>:=</a> value ]
--   </pre>
setTableChildBottomAttach :: MonadIO m => TableChild -> Word16 -> m ()

-- | Get the value of the “<tt>xpadding</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableChild #xpadding
--   </pre>
getTableChildXpadding :: MonadIO m => TableChild -> m Word16

-- | Set the value of the “<tt>xpadding</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableChild [ #xpadding <a>:=</a> value ]
--   </pre>
setTableChildXpadding :: MonadIO m => TableChild -> Word16 -> m ()

-- | Get the value of the “<tt>ypadding</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableChild #ypadding
--   </pre>
getTableChildYpadding :: MonadIO m => TableChild -> m Word16

-- | Set the value of the “<tt>ypadding</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableChild [ #ypadding <a>:=</a> value ]
--   </pre>
setTableChildYpadding :: MonadIO m => TableChild -> Word16 -> m ()

-- | Get the value of the “<tt>xexpand</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableChild #xexpand
--   </pre>
getTableChildXexpand :: MonadIO m => TableChild -> m Word32

-- | Set the value of the “<tt>xexpand</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableChild [ #xexpand <a>:=</a> value ]
--   </pre>
setTableChildXexpand :: MonadIO m => TableChild -> Word32 -> m ()

-- | Get the value of the “<tt>yexpand</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableChild #yexpand
--   </pre>
getTableChildYexpand :: MonadIO m => TableChild -> m Word32

-- | Set the value of the “<tt>yexpand</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableChild [ #yexpand <a>:=</a> value ]
--   </pre>
setTableChildYexpand :: MonadIO m => TableChild -> Word32 -> m ()

-- | Get the value of the “<tt>xshrink</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableChild #xshrink
--   </pre>
getTableChildXshrink :: MonadIO m => TableChild -> m Word32

-- | Set the value of the “<tt>xshrink</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableChild [ #xshrink <a>:=</a> value ]
--   </pre>
setTableChildXshrink :: MonadIO m => TableChild -> Word32 -> m ()

-- | Get the value of the “<tt>yshrink</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableChild #yshrink
--   </pre>
getTableChildYshrink :: MonadIO m => TableChild -> m Word32

-- | Set the value of the “<tt>yshrink</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableChild [ #yshrink <a>:=</a> value ]
--   </pre>
setTableChildYshrink :: MonadIO m => TableChild -> Word32 -> m ()

-- | Get the value of the “<tt>xfill</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableChild #xfill
--   </pre>
getTableChildXfill :: MonadIO m => TableChild -> m Word32

-- | Set the value of the “<tt>xfill</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableChild [ #xfill <a>:=</a> value ]
--   </pre>
setTableChildXfill :: MonadIO m => TableChild -> Word32 -> m ()

-- | Get the value of the “<tt>yfill</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> tableChild #yfill
--   </pre>
getTableChildYfill :: MonadIO m => TableChild -> m Word32

-- | Set the value of the “<tt>yfill</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> tableChild [ #yfill <a>:=</a> value ]
--   </pre>
setTableChildYfill :: MonadIO m => TableChild -> Word32 -> m ()

-- | Creates a new linear gradient along the line defined by (x0, y0) and
--   (x1, y1). Before using the gradient a number of stop colors must be
--   added through <a>gradientAddColorStop</a>.
--   
--   <i>Since: 3.0</i>
gradientNewLinear :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> Double -> m Gradient

-- | Creates a new radial gradient along the two circles defined by (x0,
--   y0, radius0) and (x1, y1, radius1). Before using the gradient a number
--   of stop colors must be added through <a>gradientAddColorStop</a>.
--   
--   <i>Since: 3.0</i>
gradientNewRadial :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> Double -> Double -> Double -> m Gradient

-- | Adds a stop color to <i><tt>gradient</tt></i>.
--   
--   <i>Since: 3.0</i>
gradientAddColorStop :: (HasCallStack, MonadIO m) => Gradient -> Double -> SymbolicColor -> m ()

-- | Increases the reference count of <i><tt>gradient</tt></i>.
--   
--   <i>Since: 3.0</i>
gradientRef :: (HasCallStack, MonadIO m) => Gradient -> m Gradient

-- | If <i><tt>gradient</tt></i> is resolvable,
--   <i><tt>resolvedGradient</tt></i> will be filled in with the resolved
--   gradient as a cairo_pattern_t, and <a>True</a> will be returned.
--   Generally, if <i><tt>gradient</tt></i> can’t be resolved, it is due to
--   it being defined on top of a named color that doesn't exist in
--   <i><tt>props</tt></i>.
--   
--   <i>Since: 3.0</i>
gradientResolve :: (HasCallStack, MonadIO m, IsStyleProperties a) => Gradient -> a -> m (Bool, Pattern)

-- | <i>No description available in the introspection data.</i>
gradientResolveForContext :: (HasCallStack, MonadIO m, IsStyleContext a) => Gradient -> a -> m Pattern

-- | Creates a string representation for <i><tt>gradient</tt></i> that is
--   suitable for using in GTK CSS files.
gradientToString :: (HasCallStack, MonadIO m) => Gradient -> m Text

-- | Decreases the reference count of <i><tt>gradient</tt></i>, freeing its
--   memory if the reference count reaches 0.
--   
--   <i>Since: 3.0</i>
gradientUnref :: (HasCallStack, MonadIO m) => Gradient -> m ()

-- | Construct a <a>FixedChild</a> struct initialized to zero.
newZeroFixedChild :: MonadIO m => m FixedChild

-- | Get the value of the “<tt>widget</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fixedChild #widget
--   </pre>
getFixedChildWidget :: MonadIO m => FixedChild -> m (Maybe Widget)

-- | Set the value of the “<tt>widget</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fixedChild [ #widget <a>:=</a> value ]
--   </pre>
setFixedChildWidget :: MonadIO m => FixedChild -> Ptr Widget -> m ()

-- | Set the value of the “<tt>widget</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #widget
--   </pre>
clearFixedChildWidget :: MonadIO m => FixedChild -> m ()

-- | Get the value of the “<tt>x</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fixedChild #x
--   </pre>
getFixedChildX :: MonadIO m => FixedChild -> m Int32

-- | Set the value of the “<tt>x</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fixedChild [ #x <a>:=</a> value ]
--   </pre>
setFixedChildX :: MonadIO m => FixedChild -> Int32 -> m ()

-- | Get the value of the “<tt>y</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fixedChild #y
--   </pre>
getFixedChildY :: MonadIO m => FixedChild -> m Int32

-- | Set the value of the “<tt>y</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fixedChild [ #y <a>:=</a> value ]
--   </pre>
setFixedChildY :: MonadIO m => FixedChild -> Int32 -> m ()

-- | Cast to <a>Viewport</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toViewport :: (MonadIO m, IsViewport o) => o -> m Viewport

-- | Get the value of the “<tt>shadow-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> viewport #shadowType
--   </pre>
getViewportShadowType :: (MonadIO m, IsViewport o) => o -> m ShadowType

-- | Set the value of the “<tt>shadow-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> viewport [ #shadowType <a>:=</a> value ]
--   </pre>
setViewportShadowType :: (MonadIO m, IsViewport o) => o -> ShadowType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>shadow-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructViewportShadowType :: (IsViewport o, MonadIO m) => ShadowType -> m (GValueConstruct o)

-- | Creates a new <a>Viewport</a> with the given adjustments, or with
--   default adjustments if none are given.
viewportNew :: (HasCallStack, MonadIO m, IsAdjustment a, IsAdjustment b) => Maybe a -> Maybe b -> m Viewport

-- | Gets the bin window of the <a>Viewport</a>.
--   
--   <i>Since: 2.20</i>
viewportGetBinWindow :: (HasCallStack, MonadIO m, IsViewport a) => a -> m Window

-- | Returns the horizontal adjustment of the viewport.
viewportGetHadjustment :: (HasCallStack, MonadIO m, IsViewport a) => a -> m Adjustment

-- | Gets the shadow type of the <a>Viewport</a>. See
--   <a>viewportSetShadowType</a>.
viewportGetShadowType :: (HasCallStack, MonadIO m, IsViewport a) => a -> m ShadowType

-- | Returns the vertical adjustment of the viewport.
viewportGetVadjustment :: (HasCallStack, MonadIO m, IsViewport a) => a -> m Adjustment

-- | Gets the view window of the <a>Viewport</a>.
--   
--   <i>Since: 2.22</i>
viewportGetViewWindow :: (HasCallStack, MonadIO m, IsViewport a) => a -> m Window

-- | Sets the horizontal adjustment of the viewport.
viewportSetHadjustment :: (HasCallStack, MonadIO m, IsViewport a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Sets the shadow type of the viewport.
viewportSetShadowType :: (HasCallStack, MonadIO m, IsViewport a) => a -> ShadowType -> m ()

-- | Sets the vertical adjustment of the viewport.
viewportSetVadjustment :: (HasCallStack, MonadIO m, IsViewport a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Cast to <a>ToplevelAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toToplevelAccessible :: (MonadIO m, IsToplevelAccessible o) => o -> m ToplevelAccessible

-- | <i>No description available in the introspection data.</i>
toplevelAccessibleGetChildren :: (HasCallStack, MonadIO m, IsToplevelAccessible a) => a -> m [Window]

-- | Cast to <a>ThemingEngine</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toThemingEngine :: (MonadIO m, IsThemingEngine o) => o -> m ThemingEngine

-- | Get the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> themingEngine #name
--   </pre>
getThemingEngineName :: (MonadIO m, IsThemingEngine o) => o -> m (Maybe Text)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>name</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructThemingEngineName :: (IsThemingEngine o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Gets the background color for a given state.
--   
--   <i>Since: 3.0</i>
themingEngineGetBackgroundColor :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m RGBA

-- | Gets the border for a given state as a <a>Border</a>.
--   
--   <i>Since: 3.0</i>
themingEngineGetBorder :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m Border

-- | Gets the border color for a given state.
--   
--   <i>Since: 3.0</i>
themingEngineGetBorderColor :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m RGBA

-- | Gets the foreground color for a given state.
--   
--   <i>Since: 3.0</i>
themingEngineGetColor :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m RGBA

-- | Returns the widget direction used for rendering.
--   
--   <i>Since: 3.0</i>
themingEngineGetDirection :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> m TextDirection

-- | Returns the font description for a given state.
--   
--   <i>Since: 3.0</i>
themingEngineGetFont :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m FontDescription

-- | Returns the widget direction used for rendering.
--   
--   <i>Since: 3.0</i>
themingEngineGetJunctionSides :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> m [JunctionSides]

-- | Gets the margin for a given state as a <a>Border</a>.
--   
--   <i>Since: 3.0</i>
themingEngineGetMargin :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m Border

-- | Gets the padding for a given state as a <a>Border</a>.
--   
--   <i>Since: 3.0</i>
themingEngineGetPadding :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> [StateFlags] -> m Border

-- | Returns the widget path used for style matching.
--   
--   <i>Since: 3.0</i>
themingEngineGetPath :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> m WidgetPath

-- | Gets a property value as retrieved from the style settings that apply
--   to the currently rendered element.
--   
--   <i>Since: 3.0</i>
themingEngineGetProperty :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> [StateFlags] -> m GValue

-- | Returns the <a>Screen</a> to which <i><tt>engine</tt></i> currently
--   rendering to.
themingEngineGetScreen :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> m (Maybe Screen)

-- | returns the state used when rendering.
--   
--   <i>Since: 3.0</i>
themingEngineGetState :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> m [StateFlags]

-- | Gets the value for a widget style property.
--   
--   <i>Since: 3.0</i>
themingEngineGetStyleProperty :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> m GValue

-- | Returns <a>True</a> if the currently rendered contents have defined
--   the given class name.
--   
--   <i>Since: 3.0</i>
themingEngineHasClass :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> m Bool

-- | Returns <a>True</a> if the currently rendered contents have the region
--   defined. If <i><tt>flagsReturn</tt></i> is not <a>Nothing</a>, it is
--   set to the flags affecting the region.
--   
--   <i>Since: 3.0</i>
themingEngineHasRegion :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> m (Bool, [RegionFlags])

-- | Looks up and resolves a color name in the current style’s color map.
--   
--   <i>Since: 3.0</i>
themingEngineLookupColor :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> Text -> m (Bool, RGBA)

-- | Returns <a>True</a> if there is a transition animation running for the
--   current region (see <a>styleContextPushAnimatableRegion</a>).
--   
--   If <i><tt>progress</tt></i> is not <a>Nothing</a>, the animation
--   progress will be returned there, 0.0 means the state is closest to
--   being <a>False</a>, while 1.0 means it’s closest to being <a>True</a>.
--   This means transition animations will run from 0 to 1 when
--   <i><tt>state</tt></i> is being set to <a>True</a> and from 1 to 0 when
--   it’s being set to <a>False</a>.
--   
--   <i>Since: 3.0</i>
themingEngineStateIsRunning :: (HasCallStack, MonadIO m, IsThemingEngine a) => a -> StateType -> m (Bool, Double)

-- | Loads and initializes a theming engine module from the standard
--   directories.
themingEngineLoad :: (HasCallStack, MonadIO m) => Text -> m (Maybe ThemingEngine)

-- | Cast to <a>TextView</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toTextView :: (MonadIO m, IsTextView o) => o -> m TextView

-- | Connect a signal handler for the <a>backspace</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textView #backspace callback
--   </pre>
onTextViewBackspace :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewBackspaceCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>backspace</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textView #backspace callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewBackspace :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewBackspaceCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>copyClipboard</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #copyClipboard callback
--   </pre>
onTextViewCopyClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewCopyClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>copyClipboard</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #copyClipboard callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewCopyClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewCopyClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cutClipboard</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textView #cutClipboard callback
--   </pre>
onTextViewCutClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewCutClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cutClipboard</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textView #cutClipboard callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewCutClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewCutClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteFromCursor</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #deleteFromCursor callback
--   </pre>
onTextViewDeleteFromCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewDeleteFromCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteFromCursor</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #deleteFromCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewDeleteFromCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewDeleteFromCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>extendSelection</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #extendSelection callback
--   </pre>
onTextViewExtendSelection :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewExtendSelectionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>extendSelection</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #extendSelection callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewExtendSelection :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewExtendSelectionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertAtCursor</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #insertAtCursor callback
--   </pre>
onTextViewInsertAtCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewInsertAtCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertAtCursor</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #insertAtCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewInsertAtCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewInsertAtCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertEmoji</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textView #insertEmoji callback
--   </pre>
onTextViewInsertEmoji :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewInsertEmojiCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertEmoji</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textView #insertEmoji callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewInsertEmoji :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewInsertEmojiCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textView #moveCursor callback
--   </pre>
onTextViewMoveCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textView #moveCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewMoveCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveViewport</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textView #moveViewport callback
--   </pre>
onTextViewMoveViewport :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewMoveViewportCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveViewport</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textView #moveViewport callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewMoveViewport :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewMoveViewportCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pasteClipboard</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #pasteClipboard callback
--   </pre>
onTextViewPasteClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewPasteClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pasteClipboard</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #pasteClipboard callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewPasteClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewPasteClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>populatePopup</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #populatePopup callback
--   </pre>
onTextViewPopulatePopup :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewPopulatePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>populatePopup</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #populatePopup callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewPopulatePopup :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewPopulatePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preeditChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #preeditChanged callback
--   </pre>
onTextViewPreeditChanged :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewPreeditChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preeditChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #preeditChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewPreeditChanged :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewPreeditChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textView #selectAll callback
--   </pre>
onTextViewSelectAll :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textView #selectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewSelectAll :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>setAnchor</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textView #setAnchor callback
--   </pre>
onTextViewSetAnchor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewSetAnchorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>setAnchor</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textView #setAnchor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewSetAnchor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewSetAnchorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleCursorVisible</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #toggleCursorVisible callback
--   </pre>
onTextViewToggleCursorVisible :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewToggleCursorVisibleCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleCursorVisible</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #toggleCursorVisible callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewToggleCursorVisible :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewToggleCursorVisibleCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleOverwrite</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #toggleOverwrite callback
--   </pre>
onTextViewToggleOverwrite :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewToggleOverwriteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleOverwrite</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #toggleOverwrite callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewToggleOverwrite :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewToggleOverwriteCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>accepts-tab</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #acceptsTab
--   </pre>
getTextViewAcceptsTab :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “<tt>accepts-tab</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #acceptsTab <a>:=</a> value ]
--   </pre>
setTextViewAcceptsTab :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accepts-tab</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextViewAcceptsTab :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>bottom-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #bottomMargin
--   </pre>
getTextViewBottomMargin :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “<tt>bottom-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #bottomMargin <a>:=</a> value ]
--   </pre>
setTextViewBottomMargin :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>bottom-margin</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextViewBottomMargin :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #buffer
--   </pre>
getTextViewBuffer :: (MonadIO m, IsTextView o) => o -> m TextBuffer

-- | Set the value of the “<tt>buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #buffer <a>:=</a> value ]
--   </pre>
setTextViewBuffer :: (MonadIO m, IsTextView o, IsTextBuffer a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>buffer</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextViewBuffer :: (IsTextView o, MonadIO m, IsTextBuffer a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>buffer</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #buffer
--   </pre>
clearTextViewBuffer :: (MonadIO m, IsTextView o) => o -> m ()

-- | Get the value of the “<tt>cursor-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #cursorVisible
--   </pre>
getTextViewCursorVisible :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “<tt>cursor-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #cursorVisible <a>:=</a> value ]
--   </pre>
setTextViewCursorVisible :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cursor-visible</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextViewCursorVisible :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>editable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #editable
--   </pre>
getTextViewEditable :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “<tt>editable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #editable <a>:=</a> value ]
--   </pre>
setTextViewEditable :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>editable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextViewEditable :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>im-module</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #imModule
--   </pre>
getTextViewImModule :: (MonadIO m, IsTextView o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>im-module</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #imModule <a>:=</a> value ]
--   </pre>
setTextViewImModule :: (MonadIO m, IsTextView o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>im-module</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextViewImModule :: (IsTextView o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>im-module</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #imModule
--   </pre>
clearTextViewImModule :: (MonadIO m, IsTextView o) => o -> m ()

-- | Get the value of the “<tt>indent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #indent
--   </pre>
getTextViewIndent :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “<tt>indent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #indent <a>:=</a> value ]
--   </pre>
setTextViewIndent :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>indent</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextViewIndent :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>input-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #inputHints
--   </pre>
getTextViewInputHints :: (MonadIO m, IsTextView o) => o -> m [InputHints]

-- | Set the value of the “<tt>input-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #inputHints <a>:=</a> value ]
--   </pre>
setTextViewInputHints :: (MonadIO m, IsTextView o) => o -> [InputHints] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-hints</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextViewInputHints :: (IsTextView o, MonadIO m) => [InputHints] -> m (GValueConstruct o)

-- | Get the value of the “<tt>input-purpose</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #inputPurpose
--   </pre>
getTextViewInputPurpose :: (MonadIO m, IsTextView o) => o -> m InputPurpose

-- | Set the value of the “<tt>input-purpose</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #inputPurpose <a>:=</a> value ]
--   </pre>
setTextViewInputPurpose :: (MonadIO m, IsTextView o) => o -> InputPurpose -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-purpose</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextViewInputPurpose :: (IsTextView o, MonadIO m) => InputPurpose -> m (GValueConstruct o)

-- | Get the value of the “<tt>justification</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #justification
--   </pre>
getTextViewJustification :: (MonadIO m, IsTextView o) => o -> m Justification

-- | Set the value of the “<tt>justification</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #justification <a>:=</a> value ]
--   </pre>
setTextViewJustification :: (MonadIO m, IsTextView o) => o -> Justification -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>justification</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextViewJustification :: (IsTextView o, MonadIO m) => Justification -> m (GValueConstruct o)

-- | Get the value of the “<tt>left-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #leftMargin
--   </pre>
getTextViewLeftMargin :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “<tt>left-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #leftMargin <a>:=</a> value ]
--   </pre>
setTextViewLeftMargin :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>left-margin</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextViewLeftMargin :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>monospace</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #monospace
--   </pre>
getTextViewMonospace :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “<tt>monospace</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #monospace <a>:=</a> value ]
--   </pre>
setTextViewMonospace :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>monospace</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextViewMonospace :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>overwrite</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #overwrite
--   </pre>
getTextViewOverwrite :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “<tt>overwrite</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #overwrite <a>:=</a> value ]
--   </pre>
setTextViewOverwrite :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>overwrite</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextViewOverwrite :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-above-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #pixelsAboveLines
--   </pre>
getTextViewPixelsAboveLines :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “<tt>pixels-above-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #pixelsAboveLines <a>:=</a> value ]
--   </pre>
setTextViewPixelsAboveLines :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-above-lines</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextViewPixelsAboveLines :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-below-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #pixelsBelowLines
--   </pre>
getTextViewPixelsBelowLines :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “<tt>pixels-below-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #pixelsBelowLines <a>:=</a> value ]
--   </pre>
setTextViewPixelsBelowLines :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-below-lines</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextViewPixelsBelowLines :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-inside-wrap</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #pixelsInsideWrap
--   </pre>
getTextViewPixelsInsideWrap :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “<tt>pixels-inside-wrap</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #pixelsInsideWrap <a>:=</a> value ]
--   </pre>
setTextViewPixelsInsideWrap :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-inside-wrap</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextViewPixelsInsideWrap :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>populate-all</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #populateAll
--   </pre>
getTextViewPopulateAll :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “<tt>populate-all</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #populateAll <a>:=</a> value ]
--   </pre>
setTextViewPopulateAll :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>populate-all</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextViewPopulateAll :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>right-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #rightMargin
--   </pre>
getTextViewRightMargin :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “<tt>right-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #rightMargin <a>:=</a> value ]
--   </pre>
setTextViewRightMargin :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>right-margin</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextViewRightMargin :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>tabs</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #tabs
--   </pre>
getTextViewTabs :: (MonadIO m, IsTextView o) => o -> m (Maybe TabArray)

-- | Set the value of the “<tt>tabs</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #tabs <a>:=</a> value ]
--   </pre>
setTextViewTabs :: (MonadIO m, IsTextView o) => o -> TabArray -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tabs</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextViewTabs :: (IsTextView o, MonadIO m) => TabArray -> m (GValueConstruct o)

-- | Get the value of the “<tt>top-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #topMargin
--   </pre>
getTextViewTopMargin :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “<tt>top-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #topMargin <a>:=</a> value ]
--   </pre>
setTextViewTopMargin :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>top-margin</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextViewTopMargin :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #wrapMode
--   </pre>
getTextViewWrapMode :: (MonadIO m, IsTextView o) => o -> m WrapMode

-- | Set the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #wrapMode <a>:=</a> value ]
--   </pre>
setTextViewWrapMode :: (MonadIO m, IsTextView o) => o -> WrapMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap-mode</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextViewWrapMode :: (IsTextView o, MonadIO m) => WrapMode -> m (GValueConstruct o)

-- | Creates a new <a>TextView</a>. If you don’t call
--   <a>textViewSetBuffer</a> before using the text view, an empty default
--   buffer will be created for you. Get the buffer with
--   <a>textViewGetBuffer</a>. If you want to specify your own buffer,
--   consider <a>textViewNewWithBuffer</a>.
textViewNew :: (HasCallStack, MonadIO m) => m TextView

-- | Creates a new <a>TextView</a> widget displaying the buffer
--   <i><tt>buffer</tt></i>. One buffer can be shared among many widgets.
--   <i><tt>buffer</tt></i> may be <a>Nothing</a> to create a default
--   buffer, in which case this function is equivalent to
--   <a>textViewNew</a>. The text view adds its own reference count to the
--   buffer; it does not take over an existing reference.
textViewNewWithBuffer :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TextView

-- | Adds a child widget in the text buffer, at the given
--   <i><tt>anchor</tt></i>.
textViewAddChildAtAnchor :: (HasCallStack, MonadIO m, IsTextView a, IsWidget b, IsTextChildAnchor c) => a -> b -> c -> m ()

-- | Adds a child at fixed coordinates in one of the text widget's windows.
--   
--   The window must have nonzero size (see
--   <a>textViewSetBorderWindowSize</a>). Note that the child coordinates
--   are given relative to scrolling. When placing a child in
--   <tt><i>GTK_TEXT_WINDOW_WIDGET</i></tt>, scrolling is irrelevant, the
--   child floats above all scrollable areas. But when placing a child in
--   one of the scrollable windows (border windows or text window) it will
--   move with the scrolling as needed.
textViewAddChildInWindow :: (HasCallStack, MonadIO m, IsTextView a, IsWidget b) => a -> b -> TextWindowType -> Int32 -> Int32 -> m ()

-- | Moves the given <i><tt>iter</tt></i> backward by one display (wrapped)
--   line. A display line is different from a paragraph. Paragraphs are
--   separated by newlines or other paragraph separator characters. Display
--   lines are created by line-wrapping a paragraph. If wrapping is turned
--   off, display lines and paragraphs will be the same. Display lines are
--   divided differently for each view, since they depend on the view’s
--   width; paragraphs are the same in all views, since they depend on the
--   contents of the <a>TextBuffer</a>.
textViewBackwardDisplayLine :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Bool

-- | Moves the given <i><tt>iter</tt></i> backward to the next display line
--   start. A display line is different from a paragraph. Paragraphs are
--   separated by newlines or other paragraph separator characters. Display
--   lines are created by line-wrapping a paragraph. If wrapping is turned
--   off, display lines and paragraphs will be the same. Display lines are
--   divided differently for each view, since they depend on the view’s
--   width; paragraphs are the same in all views, since they depend on the
--   contents of the <a>TextBuffer</a>.
textViewBackwardDisplayLineStart :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Bool

-- | Converts coordinate (<i><tt>bufferX</tt></i>, <i><tt>bufferY</tt></i>)
--   to coordinates for the window <i><tt>win</tt></i>, and stores the
--   result in (<i><tt>windowX</tt></i>, <i><tt>windowY</tt></i>).
--   
--   Note that you can’t convert coordinates for a nonexisting window (see
--   <a>textViewSetBorderWindowSize</a>).
textViewBufferToWindowCoords :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextWindowType -> Int32 -> Int32 -> m (Int32, Int32)

-- | Moves the given <i><tt>iter</tt></i> forward by one display (wrapped)
--   line. A display line is different from a paragraph. Paragraphs are
--   separated by newlines or other paragraph separator characters. Display
--   lines are created by line-wrapping a paragraph. If wrapping is turned
--   off, display lines and paragraphs will be the same. Display lines are
--   divided differently for each view, since they depend on the view’s
--   width; paragraphs are the same in all views, since they depend on the
--   contents of the <a>TextBuffer</a>.
textViewForwardDisplayLine :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Bool

-- | Moves the given <i><tt>iter</tt></i> forward to the next display line
--   end. A display line is different from a paragraph. Paragraphs are
--   separated by newlines or other paragraph separator characters. Display
--   lines are created by line-wrapping a paragraph. If wrapping is turned
--   off, display lines and paragraphs will be the same. Display lines are
--   divided differently for each view, since they depend on the view’s
--   width; paragraphs are the same in all views, since they depend on the
--   contents of the <a>TextBuffer</a>.
textViewForwardDisplayLineEnd :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Bool

-- | Returns whether pressing the Tab key inserts a tab characters.
--   <a>textViewSetAcceptsTab</a>.
--   
--   <i>Since: 2.4</i>
textViewGetAcceptsTab :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Bool

-- | Gets the width of the specified border window. See
--   <a>textViewSetBorderWindowSize</a>.
textViewGetBorderWindowSize :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextWindowType -> m Int32

-- | Gets the bottom margin for text in the <i><tt>textView</tt></i>.
--   
--   <i>Since: 3.18</i>
textViewGetBottomMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Returns the <a>TextBuffer</a> being displayed by this text view. The
--   reference count on the buffer is not incremented; the caller of this
--   function won’t own a new reference.
textViewGetBuffer :: (HasCallStack, MonadIO m, IsTextView a) => a -> m TextBuffer

-- | Given an <i><tt>iter</tt></i> within a text layout, determine the
--   positions of the strong and weak cursors if the insertion point is at
--   that iterator. The position of each cursor is stored as a zero-width
--   rectangle. The strong cursor location is the location where characters
--   of the directionality equal to the base direction of the paragraph are
--   inserted. The weak cursor location is the location where characters of
--   the directionality opposite to the base direction of the paragraph are
--   inserted.
--   
--   If <i><tt>iter</tt></i> is <a>Nothing</a>, the actual cursor position
--   is used.
--   
--   Note that if <i><tt>iter</tt></i> happens to be the actual cursor
--   position, and there is currently an IM preedit sequence being entered,
--   the returned locations will be adjusted to account for the preedit
--   cursor’s offset within the preedit sequence.
--   
--   The rectangle position is in buffer coordinates; use
--   <a>textViewBufferToWindowCoords</a> to convert these coordinates to
--   coordinates for one of the windows in the text view.
--   
--   <i>Since: 3.0</i>
textViewGetCursorLocations :: (HasCallStack, MonadIO m, IsTextView a) => a -> Maybe TextIter -> m (Rectangle, Rectangle)

-- | Find out whether the cursor should be displayed.
textViewGetCursorVisible :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Bool

-- | Gets the horizontal-scrolling <a>Adjustment</a>.
--   
--   <i>Since: 2.22</i>
textViewGetHadjustment :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Adjustment

-- | Gets the default indentation of paragraphs in
--   <i><tt>textView</tt></i>. Tags in the view’s buffer may override the
--   default. The indentation may be negative.
textViewGetIndent :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the value of the <a>TextView:inputHints</a> property.
--   
--   <i>Since: 3.6</i>
textViewGetInputHints :: (HasCallStack, MonadIO m, IsTextView a) => a -> m [InputHints]

-- | Gets the value of the <a>TextView:inputPurpose</a> property.
--   
--   <i>Since: 3.6</i>
textViewGetInputPurpose :: (HasCallStack, MonadIO m, IsTextView a) => a -> m InputPurpose

-- | Retrieves the iterator at buffer coordinates <i><tt>x</tt></i> and
--   <i><tt>y</tt></i>. Buffer coordinates are coordinates for the entire
--   buffer, not just the currently-displayed portion. If you have
--   coordinates from an event, you have to convert those to buffer
--   coordinates with <a>textViewWindowToBufferCoords</a>.
textViewGetIterAtLocation :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> Int32 -> m (Bool, TextIter)

-- | Retrieves the iterator pointing to the character at buffer coordinates
--   <i><tt>x</tt></i> and <i><tt>y</tt></i>. Buffer coordinates are
--   coordinates for the entire buffer, not just the currently-displayed
--   portion. If you have coordinates from an event, you have to convert
--   those to buffer coordinates with <a>textViewWindowToBufferCoords</a>.
--   
--   Note that this is different from <a>textViewGetIterAtLocation</a>,
--   which returns cursor locations, i.e. positions between characters.
--   
--   <i>Since: 2.6</i>
textViewGetIterAtPosition :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> Int32 -> m (Bool, TextIter, Int32)

-- | Gets a rectangle which roughly contains the character at
--   <i><tt>iter</tt></i>. The rectangle position is in buffer coordinates;
--   use <a>textViewBufferToWindowCoords</a> to convert these coordinates
--   to coordinates for one of the windows in the text view.
textViewGetIterLocation :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Rectangle

-- | Gets the default justification of paragraphs in
--   <i><tt>textView</tt></i>. Tags in the buffer may override the default.
textViewGetJustification :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Justification

-- | Gets the default left margin size of paragraphs in the
--   <i><tt>textView</tt></i>. Tags in the buffer may override the default.
textViewGetLeftMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the <a>TextIter</a> at the start of the line containing the
--   coordinate <i><tt>y</tt></i>. <i><tt>y</tt></i> is in buffer
--   coordinates, convert from window coordinates with
--   <a>textViewWindowToBufferCoords</a>. If non-<a>Nothing</a>,
--   <i><tt>lineTop</tt></i> will be filled with the coordinate of the top
--   edge of the line.
textViewGetLineAtY :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m (TextIter, Int32)

-- | Gets the y coordinate of the top of the line containing
--   <i><tt>iter</tt></i>, and the height of the line. The coordinate is a
--   buffer coordinate; convert to window coordinates with
--   <a>textViewBufferToWindowCoords</a>.
textViewGetLineYrange :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m (Int32, Int32)

-- | Gets the value of the <a>TextView:monospace</a> property.
--   
--   <i>Since: 3.16</i>
textViewGetMonospace :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Bool

-- | Returns whether the <a>TextView</a> is in overwrite mode or not.
--   
--   <i>Since: 2.4</i>
textViewGetOverwrite :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Bool

-- | Gets the default number of pixels to put above paragraphs. Adding this
--   function with <a>textViewGetPixelsBelowLines</a> is equal to the line
--   space between each paragraph.
textViewGetPixelsAboveLines :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the value set by <a>textViewSetPixelsBelowLines</a>.
--   
--   The line space is the sum of the value returned by this function and
--   the value returned by <a>textViewGetPixelsAboveLines</a>.
textViewGetPixelsBelowLines :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the value set by <a>textViewSetPixelsInsideWrap</a>.
textViewGetPixelsInsideWrap :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the default right margin for text in <i><tt>textView</tt></i>.
--   Tags in the buffer may override the default.
textViewGetRightMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the default tabs for <i><tt>textView</tt></i>. Tags in the buffer
--   may override the defaults. The returned array will be <a>Nothing</a>
--   if “standard” (8-space) tabs are used. Free the return value with
--   <a>tabArrayFree</a>.
textViewGetTabs :: (HasCallStack, MonadIO m, IsTextView a) => a -> m (Maybe TabArray)

-- | Gets the top margin for text in the <i><tt>textView</tt></i>.
--   
--   <i>Since: 3.18</i>
textViewGetTopMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the vertical-scrolling <a>Adjustment</a>.
--   
--   <i>Since: 2.22</i>
textViewGetVadjustment :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Adjustment

-- | Fills <i><tt>visibleRect</tt></i> with the currently-visible region of
--   the buffer, in buffer coordinates. Convert to window coordinates with
--   <a>textViewBufferToWindowCoords</a>.
textViewGetVisibleRect :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Rectangle

-- | Retrieves the <a>Window</a> corresponding to an area of the text view;
--   possible windows include the overall widget window, child windows on
--   the left, right, top, bottom, and the window that displays the text
--   buffer. Windows are <a>Nothing</a> and nonexistent if their width or
--   height is 0, and are nonexistent before the widget has been realized.
textViewGetWindow :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextWindowType -> m (Maybe Window)

-- | Usually used to find out which window an event corresponds to.
--   
--   If you connect to an event signal on <i><tt>textView</tt></i>, this
--   function should be called on <tt>event-&gt;window</tt> to see which
--   window it was.
textViewGetWindowType :: (HasCallStack, MonadIO m, IsTextView a, IsWindow b) => a -> b -> m TextWindowType

-- | Gets the line wrapping for the view.
textViewGetWrapMode :: (HasCallStack, MonadIO m, IsTextView a) => a -> m WrapMode

-- | Allow the <a>TextView</a> input method to internally handle key press
--   and release events. If this function returns <a>True</a>, then no
--   further processing should be done for this key event. See
--   <a>iMContextFilterKeypress</a>.
--   
--   Note that you are expected to call this function from your handler
--   when overriding key event handling. This is needed in the case when
--   you need to insert your own key handling between the input method and
--   the default key event handling of the <a>TextView</a>.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   static gboolean
--   gtk_foo_bar_key_press_event (GtkWidget   *widget,
--                                GdkEventKey *event)
--   {
--     guint keyval;
--   
--     gdk_event_get_keyval ((GdkEvent*)event, &amp;keyval);
--   
--     if (keyval == GDK_KEY_Return || keyval == GDK_KEY_KP_Enter)
--       {
--         if (gtk_text_view_im_context_filter_keypress (GTK_TEXT_VIEW (widget), event))
--           return TRUE;
--       }
--   
--     // Do some stuff
--   
--     return GTK_WIDGET_CLASS (gtk_foo_bar_parent_class)-&gt;key_press_event (widget, event);
--   }
--   </pre>
--   
--   <i>Since: 2.22</i>
textViewImContextFilterKeypress :: (HasCallStack, MonadIO m, IsTextView a) => a -> EventKey -> m Bool

-- | Updates the position of a child, as for
--   <a>textViewAddChildInWindow</a>.
textViewMoveChild :: (HasCallStack, MonadIO m, IsTextView a, IsWidget b) => a -> b -> Int32 -> Int32 -> m ()

-- | Moves a mark within the buffer so that it's located within the
--   currently-visible text area.
textViewMoveMarkOnscreen :: (HasCallStack, MonadIO m, IsTextView a, IsTextMark b) => a -> b -> m Bool

-- | Move the iterator a given number of characters visually, treating it
--   as the strong cursor position. If <i><tt>count</tt></i> is positive,
--   then the new strong cursor position will be <i><tt>count</tt></i>
--   positions to the right of the old cursor position. If
--   <i><tt>count</tt></i> is negative then the new strong cursor position
--   will be <i><tt>count</tt></i> positions to the left of the old cursor
--   position.
--   
--   In the presence of bi-directional text, the correspondence between
--   logical and visual order will depend on the direction of the current
--   run, and there may be jumps when the cursor is moved off of the end of
--   a run.
textViewMoveVisually :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> Int32 -> m Bool

-- | Moves the cursor to the currently visible region of the buffer, it it
--   isn’t there already.
textViewPlaceCursorOnscreen :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Bool

-- | Ensures that the cursor is shown (i.e. not in an 'off' blink interval)
--   and resets the time that it will stay blinking (or visible, in case
--   blinking is disabled).
--   
--   This function should be called in response to user input (e.g. from
--   derived classes that override the textview's
--   <a>Widget::keyPressEvent</a> handler).
--   
--   <i>Since: 3.20</i>
textViewResetCursorBlink :: (HasCallStack, MonadIO m, IsTextView a) => a -> m ()

-- | Scrolls <i><tt>textView</tt></i> the minimum distance such that
--   <i><tt>mark</tt></i> is contained within the visible area of the
--   widget.
textViewScrollMarkOnscreen :: (HasCallStack, MonadIO m, IsTextView a, IsTextMark b) => a -> b -> m ()

-- | Scrolls <i><tt>textView</tt></i> so that <i><tt>iter</tt></i> is on
--   the screen in the position indicated by <i><tt>xalign</tt></i> and
--   <i><tt>yalign</tt></i>. An alignment of 0.0 indicates left or top, 1.0
--   indicates right or bottom, 0.5 means center. If
--   <i><tt>useAlign</tt></i> is <a>False</a>, the text scrolls the minimal
--   distance to get the mark onscreen, possibly not scrolling at all. The
--   effective screen for purposes of this function is reduced by a margin
--   of size <i><tt>withinMargin</tt></i>.
--   
--   Note that this function uses the currently-computed height of the
--   lines in the text buffer. Line heights are computed in an idle
--   handler; so this function may not have the desired effect if it’s
--   called before the height computations. To avoid oddness, consider
--   using <a>textViewScrollToMark</a> which saves a point to be scrolled
--   to after line validation.
textViewScrollToIter :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> Double -> Bool -> Double -> Double -> m Bool

-- | Scrolls <i><tt>textView</tt></i> so that <i><tt>mark</tt></i> is on
--   the screen in the position indicated by <i><tt>xalign</tt></i> and
--   <i><tt>yalign</tt></i>. An alignment of 0.0 indicates left or top, 1.0
--   indicates right or bottom, 0.5 means center. If
--   <i><tt>useAlign</tt></i> is <a>False</a>, the text scrolls the minimal
--   distance to get the mark onscreen, possibly not scrolling at all. The
--   effective screen for purposes of this function is reduced by a margin
--   of size <i><tt>withinMargin</tt></i>.
textViewScrollToMark :: (HasCallStack, MonadIO m, IsTextView a, IsTextMark b) => a -> b -> Double -> Bool -> Double -> Double -> m ()

-- | Sets the behavior of the text widget when the Tab key is pressed. If
--   <i><tt>acceptsTab</tt></i> is <a>True</a>, a tab character is
--   inserted. If <i><tt>acceptsTab</tt></i> is <a>False</a> the keyboard
--   focus is moved to the next widget in the focus chain.
--   
--   <i>Since: 2.4</i>
textViewSetAcceptsTab :: (HasCallStack, MonadIO m, IsTextView a) => a -> Bool -> m ()

-- | Sets the width of <a>TextWindowTypeLeft</a> or
--   <a>TextWindowTypeRight</a>, or the height of <a>TextWindowTypeTop</a>
--   or <a>TextWindowTypeBottom</a>. Automatically destroys the
--   corresponding window if the size is set to 0, and creates the window
--   if the size is set to non-zero. This function can only be used for the
--   “border windows”, and it won’t work with <a>TextWindowTypeWidget</a>,
--   <a>TextWindowTypeText</a>, or <a>TextWindowTypePrivate</a>.
textViewSetBorderWindowSize :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextWindowType -> Int32 -> m ()

-- | Sets the bottom margin for text in <i><tt>textView</tt></i>.
--   
--   Note that this function is confusingly named. In CSS terms, the value
--   set here is padding.
--   
--   <i>Since: 3.18</i>
textViewSetBottomMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets <i><tt>buffer</tt></i> as the buffer being displayed by
--   <i><tt>textView</tt></i>. The previous buffer displayed by the text
--   view is unreferenced, and a reference is added to
--   <i><tt>buffer</tt></i>. If you owned a reference to
--   <i><tt>buffer</tt></i> before passing it to this function, you must
--   remove that reference yourself; <a>TextView</a> will not “adopt” it.
textViewSetBuffer :: (HasCallStack, MonadIO m, IsTextView a, IsTextBuffer b) => a -> Maybe b -> m ()

-- | Toggles whether the insertion point should be displayed. A buffer with
--   no editable text probably shouldn’t have a visible cursor, so you may
--   want to turn the cursor off.
--   
--   Note that this property may be overridden by the
--   <a>Settings</a>:<tt><i>gtk-keynave-use-caret</i></tt> settings.
textViewSetCursorVisible :: (HasCallStack, MonadIO m, IsTextView a) => a -> Bool -> m ()

-- | Sets the default editability of the <a>TextView</a>. You can override
--   this default setting with tags in the buffer, using the “editable”
--   attribute of tags.
textViewSetEditable :: (HasCallStack, MonadIO m, IsTextView a) => a -> Bool -> m ()

-- | Sets the default indentation for paragraphs in
--   <i><tt>textView</tt></i>. Tags in the buffer may override the default.
textViewSetIndent :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets the <a>TextView:inputHints</a> property, which allows input
--   methods to fine-tune their behaviour.
--   
--   <i>Since: 3.6</i>
textViewSetInputHints :: (HasCallStack, MonadIO m, IsTextView a) => a -> [InputHints] -> m ()

-- | Sets the <a>TextView:inputPurpose</a> property which can be used by
--   on-screen keyboards and other input methods to adjust their behaviour.
--   
--   <i>Since: 3.6</i>
textViewSetInputPurpose :: (HasCallStack, MonadIO m, IsTextView a) => a -> InputPurpose -> m ()

-- | Sets the default justification of text in <i><tt>textView</tt></i>.
--   Tags in the view’s buffer may override the default.
textViewSetJustification :: (HasCallStack, MonadIO m, IsTextView a) => a -> Justification -> m ()

-- | Sets the default left margin for text in <i><tt>textView</tt></i>.
--   Tags in the buffer may override the default.
--   
--   Note that this function is confusingly named. In CSS terms, the value
--   set here is padding.
textViewSetLeftMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets the <a>TextView:monospace</a> property, which indicates that the
--   text view should use monospace fonts.
--   
--   <i>Since: 3.16</i>
textViewSetMonospace :: (HasCallStack, MonadIO m, IsTextView a) => a -> Bool -> m ()

-- | Changes the <a>TextView</a> overwrite mode.
--   
--   <i>Since: 2.4</i>
textViewSetOverwrite :: (HasCallStack, MonadIO m, IsTextView a) => a -> Bool -> m ()

-- | Sets the default number of blank pixels above paragraphs in
--   <i><tt>textView</tt></i>. Tags in the buffer for
--   <i><tt>textView</tt></i> may override the defaults.
textViewSetPixelsAboveLines :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets the default number of pixels of blank space to put below
--   paragraphs in <i><tt>textView</tt></i>. May be overridden by tags
--   applied to <i><tt>textView</tt></i>’s buffer.
textViewSetPixelsBelowLines :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets the default number of pixels of blank space to leave between
--   display/wrapped lines within a paragraph. May be overridden by tags in
--   <i><tt>textView</tt></i>’s buffer.
textViewSetPixelsInsideWrap :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets the default right margin for text in the text view. Tags in the
--   buffer may override the default.
--   
--   Note that this function is confusingly named. In CSS terms, the value
--   set here is padding.
textViewSetRightMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets the default tab stops for paragraphs in <i><tt>textView</tt></i>.
--   Tags in the buffer may override the default.
textViewSetTabs :: (HasCallStack, MonadIO m, IsTextView a) => a -> TabArray -> m ()

-- | Sets the top margin for text in <i><tt>textView</tt></i>.
--   
--   Note that this function is confusingly named. In CSS terms, the value
--   set here is padding.
--   
--   <i>Since: 3.18</i>
textViewSetTopMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets the line wrapping for the view.
textViewSetWrapMode :: (HasCallStack, MonadIO m, IsTextView a) => a -> WrapMode -> m ()

-- | Determines whether <i><tt>iter</tt></i> is at the start of a display
--   line. See <a>textViewForwardDisplayLine</a> for an explanation of
--   display lines vs. paragraphs.
textViewStartsDisplayLine :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Bool

-- | Converts coordinates on the window identified by <i><tt>win</tt></i>
--   to buffer coordinates, storing the result in
--   (<i><tt>bufferX</tt></i>,<i><tt>bufferY</tt></i>).
--   
--   Note that you can’t convert coordinates for a nonexisting window (see
--   <a>textViewSetBorderWindowSize</a>).
textViewWindowToBufferCoords :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextWindowType -> Int32 -> Int32 -> m (Int32, Int32)

-- | Cast to <a>Table</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toTable :: (MonadIO m, IsTable o) => o -> m Table

-- | Get the value of the “<tt>column-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> table #columnSpacing
--   </pre>
getTableColumnSpacing :: (MonadIO m, IsTable o) => o -> m Word32

-- | Set the value of the “<tt>column-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> table [ #columnSpacing <a>:=</a> value ]
--   </pre>
setTableColumnSpacing :: (MonadIO m, IsTable o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>column-spacing</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTableColumnSpacing :: (IsTable o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> table #homogeneous
--   </pre>
getTableHomogeneous :: (MonadIO m, IsTable o) => o -> m Bool

-- | Set the value of the “<tt>homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> table [ #homogeneous <a>:=</a> value ]
--   </pre>
setTableHomogeneous :: (MonadIO m, IsTable o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>homogeneous</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTableHomogeneous :: (IsTable o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>n-columns</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> table #nColumns
--   </pre>
getTableNColumns :: (MonadIO m, IsTable o) => o -> m Word32

-- | Set the value of the “<tt>n-columns</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> table [ #nColumns <a>:=</a> value ]
--   </pre>
setTableNColumns :: (MonadIO m, IsTable o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>n-columns</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTableNColumns :: (IsTable o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>n-rows</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> table #nRows
--   </pre>
getTableNRows :: (MonadIO m, IsTable o) => o -> m Word32

-- | Set the value of the “<tt>n-rows</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> table [ #nRows <a>:=</a> value ]
--   </pre>
setTableNRows :: (MonadIO m, IsTable o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>n-rows</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTableNRows :: (IsTable o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>row-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> table #rowSpacing
--   </pre>
getTableRowSpacing :: (MonadIO m, IsTable o) => o -> m Word32

-- | Set the value of the “<tt>row-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> table [ #rowSpacing <a>:=</a> value ]
--   </pre>
setTableRowSpacing :: (MonadIO m, IsTable o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>row-spacing</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTableRowSpacing :: (IsTable o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Used to create a new table widget. An initial size must be given by
--   specifying how many rows and columns the table should have, although
--   this can be changed later with <a>tableResize</a>.
--   <i><tt>rows</tt></i> and <i><tt>columns</tt></i> must both be in the
--   range 1 .. 65535. For historical reasons, 0 is accepted as well and is
--   silently interpreted as 1.
tableNew :: (HasCallStack, MonadIO m) => Word32 -> Word32 -> Bool -> m Table

-- | Adds a widget to a table. The number of “cells” that a widget will
--   occupy is specified by <i><tt>leftAttach</tt></i>,
--   <i><tt>rightAttach</tt></i>, <i><tt>topAttach</tt></i> and
--   <i><tt>bottomAttach</tt></i>. These each represent the leftmost,
--   rightmost, uppermost and lowest column and row numbers of the table.
--   (Columns and rows are indexed from zero).
--   
--   To make a button occupy the lower right cell of a 2x2 table, use &gt;
--   &gt;gtk_table_attach (table, button, &gt; 1, 2, // left, right attach
--   &gt; 1, 2, // top, bottom attach &gt; xoptions, yoptions, &gt;
--   xpadding, ypadding);
--   
--   If you want to make the button span the entire bottom row, use
--   <i><tt>leftAttach</tt></i> == 0 and <i><tt>rightAttach</tt></i> = 2
--   instead.
tableAttach :: (HasCallStack, MonadIO m, IsTable a, IsWidget b) => a -> b -> Word32 -> Word32 -> Word32 -> Word32 -> [AttachOptions] -> [AttachOptions] -> Word32 -> Word32 -> m ()

-- | As there are many options associated with <a>tableAttach</a>, this
--   convenience function provides the programmer with a means to add
--   children to a table with identical padding and expansion options. The
--   values used for the <a>AttachOptions</a> are <tt>GTK_EXPAND |
--   GTK_FILL</tt>, and the padding is set to 0.
tableAttachDefaults :: (HasCallStack, MonadIO m, IsTable a, IsWidget b) => a -> b -> Word32 -> Word32 -> Word32 -> Word32 -> m ()

-- | Gets the amount of space between column <i><tt>col</tt></i>, and
--   column <i><tt>col</tt></i> + 1. See <a>tableSetColSpacing</a>.
tableGetColSpacing :: (HasCallStack, MonadIO m, IsTable a) => a -> Word32 -> m Word32

-- | Gets the default column spacing for the table. This is the spacing
--   that will be used for newly added columns. (See
--   <a>tableSetColSpacings</a>)
tableGetDefaultColSpacing :: (HasCallStack, MonadIO m, IsTable a) => a -> m Word32

-- | Gets the default row spacing for the table. This is the spacing that
--   will be used for newly added rows. (See <a>tableSetRowSpacings</a>)
tableGetDefaultRowSpacing :: (HasCallStack, MonadIO m, IsTable a) => a -> m Word32

-- | Returns whether the table cells are all constrained to the same width
--   and height. (See gtk_table_set_homogeneous ())
tableGetHomogeneous :: (HasCallStack, MonadIO m, IsTable a) => a -> m Bool

-- | Gets the amount of space between row <i><tt>row</tt></i>, and row
--   <i><tt>row</tt></i> + 1. See <a>tableSetRowSpacing</a>.
tableGetRowSpacing :: (HasCallStack, MonadIO m, IsTable a) => a -> Word32 -> m Word32

-- | Gets the number of rows and columns in the table.
--   
--   <i>Since: 2.22</i>
tableGetSize :: (HasCallStack, MonadIO m, IsTable a) => a -> m (Word32, Word32)

-- | If you need to change a table’s size after it has been created, this
--   function allows you to do so.
tableResize :: (HasCallStack, MonadIO m, IsTable a) => a -> Word32 -> Word32 -> m ()

-- | Alters the amount of space between a given table column and the
--   following column.
tableSetColSpacing :: (HasCallStack, MonadIO m, IsTable a) => a -> Word32 -> Word32 -> m ()

-- | Sets the space between every column in <i><tt>table</tt></i> equal to
--   <i><tt>spacing</tt></i>.
tableSetColSpacings :: (HasCallStack, MonadIO m, IsTable a) => a -> Word32 -> m ()

-- | Changes the homogenous property of table cells, ie. whether all cells
--   are an equal size or not.
tableSetHomogeneous :: (HasCallStack, MonadIO m, IsTable a) => a -> Bool -> m ()

-- | Changes the space between a given table row and the subsequent row.
tableSetRowSpacing :: (HasCallStack, MonadIO m, IsTable a) => a -> Word32 -> Word32 -> m ()

-- | Sets the space between every row in <i><tt>table</tt></i> equal to
--   <i><tt>spacing</tt></i>.
tableSetRowSpacings :: (HasCallStack, MonadIO m, IsTable a) => a -> Word32 -> m ()

-- | Cast to <a>Stack</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toStack :: (MonadIO m, IsStack o) => o -> m Stack

-- | Get the value of the “<tt>hhomogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #hhomogeneous
--   </pre>
getStackHhomogeneous :: (MonadIO m, IsStack o) => o -> m Bool

-- | Set the value of the “<tt>hhomogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stack [ #hhomogeneous <a>:=</a> value ]
--   </pre>
setStackHhomogeneous :: (MonadIO m, IsStack o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hhomogeneous</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructStackHhomogeneous :: (IsStack o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #homogeneous
--   </pre>
getStackHomogeneous :: (MonadIO m, IsStack o) => o -> m Bool

-- | Set the value of the “<tt>homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stack [ #homogeneous <a>:=</a> value ]
--   </pre>
setStackHomogeneous :: (MonadIO m, IsStack o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>homogeneous</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructStackHomogeneous :: (IsStack o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>interpolate-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #interpolateSize
--   </pre>
getStackInterpolateSize :: (MonadIO m, IsStack o) => o -> m Bool

-- | Set the value of the “<tt>interpolate-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stack [ #interpolateSize <a>:=</a> value ]
--   </pre>
setStackInterpolateSize :: (MonadIO m, IsStack o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>interpolate-size</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructStackInterpolateSize :: (IsStack o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>transition-duration</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #transitionDuration
--   </pre>
getStackTransitionDuration :: (MonadIO m, IsStack o) => o -> m Word32

-- | Set the value of the “<tt>transition-duration</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stack [ #transitionDuration <a>:=</a> value ]
--   </pre>
setStackTransitionDuration :: (MonadIO m, IsStack o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>transition-duration</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructStackTransitionDuration :: (IsStack o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>transition-running</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #transitionRunning
--   </pre>
getStackTransitionRunning :: (MonadIO m, IsStack o) => o -> m Bool

-- | Get the value of the “<tt>transition-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #transitionType
--   </pre>
getStackTransitionType :: (MonadIO m, IsStack o) => o -> m StackTransitionType

-- | Set the value of the “<tt>transition-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stack [ #transitionType <a>:=</a> value ]
--   </pre>
setStackTransitionType :: (MonadIO m, IsStack o) => o -> StackTransitionType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>transition-type</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructStackTransitionType :: (IsStack o, MonadIO m) => StackTransitionType -> m (GValueConstruct o)

-- | Get the value of the “<tt>vhomogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #vhomogeneous
--   </pre>
getStackVhomogeneous :: (MonadIO m, IsStack o) => o -> m Bool

-- | Set the value of the “<tt>vhomogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stack [ #vhomogeneous <a>:=</a> value ]
--   </pre>
setStackVhomogeneous :: (MonadIO m, IsStack o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>vhomogeneous</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructStackVhomogeneous :: (IsStack o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #visibleChild
--   </pre>
getStackVisibleChild :: (MonadIO m, IsStack o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>visible-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stack [ #visibleChild <a>:=</a> value ]
--   </pre>
setStackVisibleChild :: (MonadIO m, IsStack o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible-child</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructStackVisibleChild :: (IsStack o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible-child-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #visibleChildName
--   </pre>
getStackVisibleChildName :: (MonadIO m, IsStack o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>visible-child-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stack [ #visibleChildName <a>:=</a> value ]
--   </pre>
setStackVisibleChildName :: (MonadIO m, IsStack o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible-child-name</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructStackVisibleChildName :: (IsStack o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Creates a new <a>Stack</a> container.
--   
--   <i>Since: 3.10</i>
stackNew :: (HasCallStack, MonadIO m) => m Stack

-- | Adds a child to <i><tt>stack</tt></i>. The child is identified by the
--   <i><tt>name</tt></i>.
--   
--   <i>Since: 3.10</i>
stackAddNamed :: (HasCallStack, MonadIO m, IsStack a, IsWidget b) => a -> b -> Text -> m ()

-- | Adds a child to <i><tt>stack</tt></i>. The child is identified by the
--   <i><tt>name</tt></i>. The <i><tt>title</tt></i> will be used by
--   <a>StackSwitcher</a> to represent <i><tt>child</tt></i> in a tab bar,
--   so it should be short.
--   
--   <i>Since: 3.10</i>
stackAddTitled :: (HasCallStack, MonadIO m, IsStack a, IsWidget b) => a -> b -> Text -> Text -> m ()

-- | Finds the child of the <a>Stack</a> with the name given as the
--   argument. Returns <a>Nothing</a> if there is no child with this name.
--   
--   <i>Since: 3.12</i>
stackGetChildByName :: (HasCallStack, MonadIO m, IsStack a) => a -> Text -> m (Maybe Widget)

-- | Gets whether <i><tt>stack</tt></i> is horizontally homogeneous. See
--   <a>stackSetHhomogeneous</a>.
--   
--   <i>Since: 3.16</i>
stackGetHhomogeneous :: (HasCallStack, MonadIO m, IsStack a) => a -> m Bool

-- | Gets whether <i><tt>stack</tt></i> is homogeneous. See
--   <a>stackSetHomogeneous</a>.
--   
--   <i>Since: 3.10</i>
stackGetHomogeneous :: (HasCallStack, MonadIO m, IsStack a) => a -> m Bool

-- | Returns wether the <a>Stack</a> is set up to interpolate between the
--   sizes of children on page switch.
--   
--   <i>Since: 3.18</i>
stackGetInterpolateSize :: (HasCallStack, MonadIO m, IsStack a) => a -> m Bool

-- | Returns the amount of time (in milliseconds) that transitions between
--   pages in <i><tt>stack</tt></i> will take.
--   
--   <i>Since: 3.10</i>
stackGetTransitionDuration :: (HasCallStack, MonadIO m, IsStack a) => a -> m Word32

-- | Returns whether the <i><tt>stack</tt></i> is currently in a transition
--   from one page to another.
--   
--   <i>Since: 3.12</i>
stackGetTransitionRunning :: (HasCallStack, MonadIO m, IsStack a) => a -> m Bool

-- | Gets the type of animation that will be used for transitions between
--   pages in <i><tt>stack</tt></i>.
--   
--   <i>Since: 3.10</i>
stackGetTransitionType :: (HasCallStack, MonadIO m, IsStack a) => a -> m StackTransitionType

-- | Gets whether <i><tt>stack</tt></i> is vertically homogeneous. See
--   <a>stackSetVhomogeneous</a>.
--   
--   <i>Since: 3.16</i>
stackGetVhomogeneous :: (HasCallStack, MonadIO m, IsStack a) => a -> m Bool

-- | Gets the currently visible child of <i><tt>stack</tt></i>, or
--   <a>Nothing</a> if there are no visible children.
--   
--   <i>Since: 3.10</i>
stackGetVisibleChild :: (HasCallStack, MonadIO m, IsStack a) => a -> m (Maybe Widget)

-- | Returns the name of the currently visible child of
--   <i><tt>stack</tt></i>, or <a>Nothing</a> if there is no visible child.
--   
--   <i>Since: 3.10</i>
stackGetVisibleChildName :: (HasCallStack, MonadIO m, IsStack a) => a -> m (Maybe Text)

-- | Sets the <a>Stack</a> to be horizontally homogeneous or not. If it is
--   homogeneous, the <a>Stack</a> will request the same width for all its
--   children. If it isn't, the stack may change width when a different
--   child becomes visible.
--   
--   <i>Since: 3.16</i>
stackSetHhomogeneous :: (HasCallStack, MonadIO m, IsStack a) => a -> Bool -> m ()

-- | Sets the <a>Stack</a> to be homogeneous or not. If it is homogeneous,
--   the <a>Stack</a> will request the same size for all its children. If
--   it isn't, the stack may change size when a different child becomes
--   visible.
--   
--   Since 3.16, homogeneity can be controlled separately for horizontal
--   and vertical size, with the <a>Stack:hhomogeneous</a> and
--   <a>Stack:vhomogeneous</a>.
--   
--   <i>Since: 3.10</i>
stackSetHomogeneous :: (HasCallStack, MonadIO m, IsStack a) => a -> Bool -> m ()

-- | Sets whether or not <i><tt>stack</tt></i> will interpolate its size
--   when changing the visible child. If the <a>Stack:interpolateSize</a>
--   property is set to <a>True</a>, <i><tt>stack</tt></i> will interpolate
--   its size between the current one and the one it'll take after changing
--   the visible child, according to the set transition duration.
--   
--   <i>Since: 3.18</i>
stackSetInterpolateSize :: (HasCallStack, MonadIO m, IsStack a) => a -> Bool -> m ()

-- | Sets the duration that transitions between pages in
--   <i><tt>stack</tt></i> will take.
--   
--   <i>Since: 3.10</i>
stackSetTransitionDuration :: (HasCallStack, MonadIO m, IsStack a) => a -> Word32 -> m ()

-- | Sets the type of animation that will be used for transitions between
--   pages in <i><tt>stack</tt></i>. Available types include various kinds
--   of fades and slides.
--   
--   The transition type can be changed without problems at runtime, so it
--   is possible to change the animation based on the page that is about to
--   become current.
--   
--   <i>Since: 3.10</i>
stackSetTransitionType :: (HasCallStack, MonadIO m, IsStack a) => a -> StackTransitionType -> m ()

-- | Sets the <a>Stack</a> to be vertically homogeneous or not. If it is
--   homogeneous, the <a>Stack</a> will request the same height for all its
--   children. If it isn't, the stack may change height when a different
--   child becomes visible.
--   
--   <i>Since: 3.16</i>
stackSetVhomogeneous :: (HasCallStack, MonadIO m, IsStack a) => a -> Bool -> m ()

-- | Makes <i><tt>child</tt></i> the visible child of
--   <i><tt>stack</tt></i>.
--   
--   If <i><tt>child</tt></i> is different from the currently visible
--   child, the transition between the two will be animated with the
--   current transition type of <i><tt>stack</tt></i>.
--   
--   Note that the <i><tt>child</tt></i> widget has to be visible itself
--   (see <a>widgetShow</a>) in order to become the visible child of
--   <i><tt>stack</tt></i>.
--   
--   <i>Since: 3.10</i>
stackSetVisibleChild :: (HasCallStack, MonadIO m, IsStack a, IsWidget b) => a -> b -> m ()

-- | Makes the child with the given name visible.
--   
--   Note that the child widget has to be visible itself (see
--   <a>widgetShow</a>) in order to become the visible child of
--   <i><tt>stack</tt></i>.
--   
--   <i>Since: 3.10</i>
stackSetVisibleChildFull :: (HasCallStack, MonadIO m, IsStack a) => a -> Text -> StackTransitionType -> m ()

-- | Makes the child with the given name visible.
--   
--   If <i><tt>child</tt></i> is different from the currently visible
--   child, the transition between the two will be animated with the
--   current transition type of <i><tt>stack</tt></i>.
--   
--   Note that the child widget has to be visible itself (see
--   <a>widgetShow</a>) in order to become the visible child of
--   <i><tt>stack</tt></i>.
--   
--   <i>Since: 3.10</i>
stackSetVisibleChildName :: (HasCallStack, MonadIO m, IsStack a) => a -> Text -> m ()

-- | Cast to <a>StackSidebar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toStackSidebar :: (MonadIO m, IsStackSidebar o) => o -> m StackSidebar

-- | Get the value of the “<tt>stack</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stackSidebar #stack
--   </pre>
getStackSidebarStack :: (MonadIO m, IsStackSidebar o) => o -> m (Maybe Stack)

-- | Set the value of the “<tt>stack</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stackSidebar [ #stack <a>:=</a> value ]
--   </pre>
setStackSidebarStack :: (MonadIO m, IsStackSidebar o, IsStack a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stack</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStackSidebarStack :: (IsStackSidebar o, MonadIO m, IsStack a) => a -> m (GValueConstruct o)

-- | Creates a new sidebar.
--   
--   <i>Since: 3.16</i>
stackSidebarNew :: (HasCallStack, MonadIO m) => m StackSidebar

-- | Retrieves the stack. See <a>stackSidebarSetStack</a>.
--   
--   <i>Since: 3.16</i>
stackSidebarGetStack :: (HasCallStack, MonadIO m, IsStackSidebar a) => a -> m (Maybe Stack)

-- | Set the <a>Stack</a> associated with this <a>StackSidebar</a>.
--   
--   The sidebar widget will automatically update according to the order
--   (packing) and items within the given <a>Stack</a>.
--   
--   <i>Since: 3.16</i>
stackSidebarSetStack :: (HasCallStack, MonadIO m, IsStackSidebar a, IsStack b) => a -> b -> m ()

-- | Cast to <a>Spinner</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toSpinner :: (MonadIO m, IsSpinner o) => o -> m Spinner

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinner #active
--   </pre>
getSpinnerActive :: (MonadIO m, IsSpinner o) => o -> m Bool

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinner [ #active <a>:=</a> value ]
--   </pre>
setSpinnerActive :: (MonadIO m, IsSpinner o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSpinnerActive :: (IsSpinner o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Returns a new spinner widget. Not yet started.
--   
--   <i>Since: 2.20</i>
spinnerNew :: (HasCallStack, MonadIO m) => m Spinner

-- | Starts the animation of the spinner.
--   
--   <i>Since: 2.20</i>
spinnerStart :: (HasCallStack, MonadIO m, IsSpinner a) => a -> m ()

-- | Stops the animation of the spinner.
--   
--   <i>Since: 2.20</i>
spinnerStop :: (HasCallStack, MonadIO m, IsSpinner a) => a -> m ()

-- | Cast to <a>Socket</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toSocket :: (MonadIO m, IsSocket o) => o -> m Socket

-- | Connect a signal handler for the <a>plugAdded</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> socket #plugAdded callback
--   </pre>
onSocketPlugAdded :: (IsSocket a, MonadIO m) => a -> ((?self :: a) => SocketPlugAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>plugAdded</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> socket #plugAdded callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSocketPlugAdded :: (IsSocket a, MonadIO m) => a -> ((?self :: a) => SocketPlugAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>plugRemoved</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> socket #plugRemoved callback
--   </pre>
onSocketPlugRemoved :: (IsSocket a, MonadIO m) => a -> ((?self :: a) => SocketPlugRemovedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>plugRemoved</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> socket #plugRemoved callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSocketPlugRemoved :: (IsSocket a, MonadIO m) => a -> ((?self :: a) => SocketPlugRemovedCallback) -> m SignalHandlerId

-- | Create a new empty <a>Socket</a>.
socketNew :: (HasCallStack, MonadIO m) => m Socket

-- | Gets the window ID of a <a>Socket</a> widget, which can then be used
--   to create a client embedded inside the socket, for instance with
--   <a>plugNew</a>.
--   
--   The <a>Socket</a> must have already be added into a toplevel window
--   before you can make this call.
socketGetId :: (HasCallStack, MonadIO m, IsSocket a) => a -> m CULong

-- | Retrieves the window of the plug. Use this to check if the plug has
--   been created inside of the socket.
--   
--   <i>Since: 2.14</i>
socketGetPlugWindow :: (HasCallStack, MonadIO m, IsSocket a) => a -> m (Maybe Window)

-- | Cast to <a>SizeGroup</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSizeGroup :: (MonadIO m, IsSizeGroup o) => o -> m SizeGroup

-- | Get the value of the “<tt>ignore-hidden</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sizeGroup #ignoreHidden
--   </pre>
getSizeGroupIgnoreHidden :: (MonadIO m, IsSizeGroup o) => o -> m Bool

-- | Set the value of the “<tt>ignore-hidden</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> sizeGroup [ #ignoreHidden <a>:=</a> value ]
--   </pre>
setSizeGroupIgnoreHidden :: (MonadIO m, IsSizeGroup o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ignore-hidden</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSizeGroupIgnoreHidden :: (IsSizeGroup o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>mode</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sizeGroup #mode
--   </pre>
getSizeGroupMode :: (MonadIO m, IsSizeGroup o) => o -> m SizeGroupMode

-- | Set the value of the “<tt>mode</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> sizeGroup [ #mode <a>:=</a> value ]
--   </pre>
setSizeGroupMode :: (MonadIO m, IsSizeGroup o) => o -> SizeGroupMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>mode</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSizeGroupMode :: (IsSizeGroup o, MonadIO m) => SizeGroupMode -> m (GValueConstruct o)

-- | Create a new <a>SizeGroup</a>.
sizeGroupNew :: (HasCallStack, MonadIO m) => SizeGroupMode -> m SizeGroup

-- | Adds a widget to a <a>SizeGroup</a>. In the future, the requisition of
--   the widget will be determined as the maximum of its requisition and
--   the requisition of the other widgets in the size group. Whether this
--   applies horizontally, vertically, or in both directions depends on the
--   mode of the size group. See <a>sizeGroupSetMode</a>.
--   
--   When the widget is destroyed or no longer referenced elsewhere, it
--   will be removed from the size group.
sizeGroupAddWidget :: (HasCallStack, MonadIO m, IsSizeGroup a, IsWidget b) => a -> b -> m ()

-- | Returns if invisible widgets are ignored when calculating the size.
--   
--   <i>Since: 2.8</i>
sizeGroupGetIgnoreHidden :: (HasCallStack, MonadIO m, IsSizeGroup a) => a -> m Bool

-- | Gets the current mode of the size group. See <a>sizeGroupSetMode</a>.
sizeGroupGetMode :: (HasCallStack, MonadIO m, IsSizeGroup a) => a -> m SizeGroupMode

-- | Returns the list of widgets associated with <i><tt>sizeGroup</tt></i>.
--   
--   <i>Since: 2.10</i>
sizeGroupGetWidgets :: (HasCallStack, MonadIO m, IsSizeGroup a) => a -> m [Widget]

-- | Removes a widget from a <a>SizeGroup</a>.
sizeGroupRemoveWidget :: (HasCallStack, MonadIO m, IsSizeGroup a, IsWidget b) => a -> b -> m ()

-- | Sets whether unmapped widgets should be ignored when calculating the
--   size.
--   
--   <i>Since: 2.8</i>
sizeGroupSetIgnoreHidden :: (HasCallStack, MonadIO m, IsSizeGroup a) => a -> Bool -> m ()

-- | Sets the <a>SizeGroupMode</a> of the size group. The mode of the size
--   group determines whether the widgets in the size group should all have
--   the same horizontal requisition (<a>SizeGroupModeHorizontal</a>) all
--   have the same vertical requisition (<a>SizeGroupModeVertical</a>), or
--   should all have the same requisition in both directions
--   (<a>SizeGroupModeBoth</a>).
sizeGroupSetMode :: (HasCallStack, MonadIO m, IsSizeGroup a) => a -> SizeGroupMode -> m ()

-- | Cast to <a>ShortcutsWindow</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toShortcutsWindow :: (MonadIO m, IsShortcutsWindow o) => o -> m ShortcutsWindow

-- | Connect a signal handler for the <a>close</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> shortcutsWindow #close callback
--   </pre>
onShortcutsWindowClose :: (IsShortcutsWindow a, MonadIO m) => a -> ((?self :: a) => ShortcutsWindowCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>close</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> shortcutsWindow #close callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterShortcutsWindowClose :: (IsShortcutsWindow a, MonadIO m) => a -> ((?self :: a) => ShortcutsWindowCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>search</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> shortcutsWindow #search callback
--   </pre>
onShortcutsWindowSearch :: (IsShortcutsWindow a, MonadIO m) => a -> ((?self :: a) => ShortcutsWindowSearchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>search</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> shortcutsWindow #search callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterShortcutsWindowSearch :: (IsShortcutsWindow a, MonadIO m) => a -> ((?self :: a) => ShortcutsWindowSearchCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>section-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsWindow #sectionName
--   </pre>
getShortcutsWindowSectionName :: (MonadIO m, IsShortcutsWindow o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>section-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsWindow [ #sectionName <a>:=</a> value ]
--   </pre>
setShortcutsWindowSectionName :: (MonadIO m, IsShortcutsWindow o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>section-name</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructShortcutsWindowSectionName :: (IsShortcutsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>section-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #sectionName
--   </pre>
clearShortcutsWindowSectionName :: (MonadIO m, IsShortcutsWindow o) => o -> m ()

-- | Get the value of the “<tt>view-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsWindow #viewName
--   </pre>
getShortcutsWindowViewName :: (MonadIO m, IsShortcutsWindow o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>view-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsWindow [ #viewName <a>:=</a> value ]
--   </pre>
setShortcutsWindowViewName :: (MonadIO m, IsShortcutsWindow o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>view-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructShortcutsWindowViewName :: (IsShortcutsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>view-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #viewName
--   </pre>
clearShortcutsWindowViewName :: (MonadIO m, IsShortcutsWindow o) => o -> m ()

-- | Cast to <a>Separator</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSeparator :: (MonadIO m, IsSeparator o) => o -> m Separator

-- | Creates a new <a>Separator</a> with the given orientation.
--   
--   <i>Since: 3.0</i>
separatorNew :: (HasCallStack, MonadIO m) => Orientation -> m Separator

-- | Cast to <a>VSeparator</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toVSeparator :: (MonadIO m, IsVSeparator o) => o -> m VSeparator

-- | Creates a new <a>VSeparator</a>.
vSeparatorNew :: (HasCallStack, MonadIO m) => m VSeparator

-- | Cast to <a>ScrolledWindow</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toScrolledWindow :: (MonadIO m, IsScrolledWindow o) => o -> m ScrolledWindow

-- | Connect a signal handler for the <a>edgeOvershot</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> scrolledWindow #edgeOvershot callback
--   </pre>
onScrolledWindowEdgeOvershot :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowEdgeOvershotCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>edgeOvershot</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> scrolledWindow #edgeOvershot callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterScrolledWindowEdgeOvershot :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowEdgeOvershotCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>edgeReached</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> scrolledWindow #edgeReached callback
--   </pre>
onScrolledWindowEdgeReached :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowEdgeReachedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>edgeReached</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> scrolledWindow #edgeReached callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterScrolledWindowEdgeReached :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowEdgeReachedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveFocusOut</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> scrolledWindow #moveFocusOut callback
--   </pre>
onScrolledWindowMoveFocusOut :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowMoveFocusOutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveFocusOut</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> scrolledWindow #moveFocusOut callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterScrolledWindowMoveFocusOut :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowMoveFocusOutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scrollChild</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> scrolledWindow #scrollChild callback
--   </pre>
onScrolledWindowScrollChild :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowScrollChildCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scrollChild</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> scrolledWindow #scrollChild callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterScrolledWindowScrollChild :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowScrollChildCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>hadjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #hadjustment
--   </pre>
getScrolledWindowHadjustment :: (MonadIO m, IsScrolledWindow o) => o -> m Adjustment

-- | Set the value of the “<tt>hadjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #hadjustment <a>:=</a> value ]
--   </pre>
setScrolledWindowHadjustment :: (MonadIO m, IsScrolledWindow o, IsAdjustment a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hadjustment</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructScrolledWindowHadjustment :: (IsScrolledWindow o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>hadjustment</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #hadjustment
--   </pre>
clearScrolledWindowHadjustment :: (MonadIO m, IsScrolledWindow o) => o -> m ()

-- | Get the value of the “<tt>hscrollbar-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #hscrollbarPolicy
--   </pre>
getScrolledWindowHscrollbarPolicy :: (MonadIO m, IsScrolledWindow o) => o -> m PolicyType

-- | Set the value of the “<tt>hscrollbar-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #hscrollbarPolicy <a>:=</a> value ]
--   </pre>
setScrolledWindowHscrollbarPolicy :: (MonadIO m, IsScrolledWindow o) => o -> PolicyType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hscrollbar-policy</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrolledWindowHscrollbarPolicy :: (IsScrolledWindow o, MonadIO m) => PolicyType -> m (GValueConstruct o)

-- | Get the value of the “<tt>kinetic-scrolling</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #kineticScrolling
--   </pre>
getScrolledWindowKineticScrolling :: (MonadIO m, IsScrolledWindow o) => o -> m Bool

-- | Set the value of the “<tt>kinetic-scrolling</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #kineticScrolling <a>:=</a> value ]
--   </pre>
setScrolledWindowKineticScrolling :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>kinetic-scrolling</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrolledWindowKineticScrolling :: (IsScrolledWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-content-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #maxContentHeight
--   </pre>
getScrolledWindowMaxContentHeight :: (MonadIO m, IsScrolledWindow o) => o -> m Int32

-- | Set the value of the “<tt>max-content-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #maxContentHeight <a>:=</a> value ]
--   </pre>
setScrolledWindowMaxContentHeight :: (MonadIO m, IsScrolledWindow o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-content-height</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructScrolledWindowMaxContentHeight :: (IsScrolledWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-content-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #maxContentWidth
--   </pre>
getScrolledWindowMaxContentWidth :: (MonadIO m, IsScrolledWindow o) => o -> m Int32

-- | Set the value of the “<tt>max-content-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #maxContentWidth <a>:=</a> value ]
--   </pre>
setScrolledWindowMaxContentWidth :: (MonadIO m, IsScrolledWindow o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-content-width</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrolledWindowMaxContentWidth :: (IsScrolledWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>min-content-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #minContentHeight
--   </pre>
getScrolledWindowMinContentHeight :: (MonadIO m, IsScrolledWindow o) => o -> m Int32

-- | Set the value of the “<tt>min-content-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #minContentHeight <a>:=</a> value ]
--   </pre>
setScrolledWindowMinContentHeight :: (MonadIO m, IsScrolledWindow o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>min-content-height</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructScrolledWindowMinContentHeight :: (IsScrolledWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>min-content-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #minContentWidth
--   </pre>
getScrolledWindowMinContentWidth :: (MonadIO m, IsScrolledWindow o) => o -> m Int32

-- | Set the value of the “<tt>min-content-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #minContentWidth <a>:=</a> value ]
--   </pre>
setScrolledWindowMinContentWidth :: (MonadIO m, IsScrolledWindow o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>min-content-width</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrolledWindowMinContentWidth :: (IsScrolledWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>overlay-scrolling</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #overlayScrolling
--   </pre>
getScrolledWindowOverlayScrolling :: (MonadIO m, IsScrolledWindow o) => o -> m Bool

-- | Set the value of the “<tt>overlay-scrolling</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #overlayScrolling <a>:=</a> value ]
--   </pre>
setScrolledWindowOverlayScrolling :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>overlay-scrolling</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrolledWindowOverlayScrolling :: (IsScrolledWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>propagate-natural-height</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #propagateNaturalHeight
--   </pre>
getScrolledWindowPropagateNaturalHeight :: (MonadIO m, IsScrolledWindow o) => o -> m Bool

-- | Set the value of the “<tt>propagate-natural-height</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #propagateNaturalHeight <a>:=</a> value ]
--   </pre>
setScrolledWindowPropagateNaturalHeight :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>propagate-natural-height</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructScrolledWindowPropagateNaturalHeight :: (IsScrolledWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>propagate-natural-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #propagateNaturalWidth
--   </pre>
getScrolledWindowPropagateNaturalWidth :: (MonadIO m, IsScrolledWindow o) => o -> m Bool

-- | Set the value of the “<tt>propagate-natural-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #propagateNaturalWidth <a>:=</a> value ]
--   </pre>
setScrolledWindowPropagateNaturalWidth :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>propagate-natural-width</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructScrolledWindowPropagateNaturalWidth :: (IsScrolledWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>shadow-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #shadowType
--   </pre>
getScrolledWindowShadowType :: (MonadIO m, IsScrolledWindow o) => o -> m ShadowType

-- | Set the value of the “<tt>shadow-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #shadowType <a>:=</a> value ]
--   </pre>
setScrolledWindowShadowType :: (MonadIO m, IsScrolledWindow o) => o -> ShadowType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>shadow-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructScrolledWindowShadowType :: (IsScrolledWindow o, MonadIO m) => ShadowType -> m (GValueConstruct o)

-- | Get the value of the “<tt>vadjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #vadjustment
--   </pre>
getScrolledWindowVadjustment :: (MonadIO m, IsScrolledWindow o) => o -> m Adjustment

-- | Set the value of the “<tt>vadjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #vadjustment <a>:=</a> value ]
--   </pre>
setScrolledWindowVadjustment :: (MonadIO m, IsScrolledWindow o, IsAdjustment a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>vadjustment</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructScrolledWindowVadjustment :: (IsScrolledWindow o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>vadjustment</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #vadjustment
--   </pre>
clearScrolledWindowVadjustment :: (MonadIO m, IsScrolledWindow o) => o -> m ()

-- | Get the value of the “<tt>vscrollbar-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #vscrollbarPolicy
--   </pre>
getScrolledWindowVscrollbarPolicy :: (MonadIO m, IsScrolledWindow o) => o -> m PolicyType

-- | Set the value of the “<tt>vscrollbar-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #vscrollbarPolicy <a>:=</a> value ]
--   </pre>
setScrolledWindowVscrollbarPolicy :: (MonadIO m, IsScrolledWindow o) => o -> PolicyType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>vscrollbar-policy</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrolledWindowVscrollbarPolicy :: (IsScrolledWindow o, MonadIO m) => PolicyType -> m (GValueConstruct o)

-- | Get the value of the “<tt>window-placement</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #windowPlacement
--   </pre>
getScrolledWindowWindowPlacement :: (MonadIO m, IsScrolledWindow o) => o -> m CornerType

-- | Set the value of the “<tt>window-placement</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #windowPlacement <a>:=</a> value ]
--   </pre>
setScrolledWindowWindowPlacement :: (MonadIO m, IsScrolledWindow o) => o -> CornerType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>window-placement</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrolledWindowWindowPlacement :: (IsScrolledWindow o, MonadIO m) => CornerType -> m (GValueConstruct o)

-- | Get the value of the “<tt>window-placement-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #windowPlacementSet
--   </pre>
getScrolledWindowWindowPlacementSet :: (MonadIO m, IsScrolledWindow o) => o -> m Bool

-- | Set the value of the “<tt>window-placement-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #windowPlacementSet <a>:=</a> value ]
--   </pre>
setScrolledWindowWindowPlacementSet :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>window-placement-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructScrolledWindowWindowPlacementSet :: (IsScrolledWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new scrolled window.
--   
--   The two arguments are the scrolled window’s adjustments; these will be
--   shared with the scrollbars and the child widget to keep the bars in
--   sync with the child. Usually you want to pass <a>Nothing</a> for the
--   adjustments, which will cause the scrolled window to create them for
--   you.
scrolledWindowNew :: (HasCallStack, MonadIO m, IsAdjustment a, IsAdjustment b) => Maybe a -> Maybe b -> m ScrolledWindow

-- | Used to add children without native scrolling capabilities. This is
--   simply a convenience function; it is equivalent to adding the
--   unscrollable child to a viewport, then adding the viewport to the
--   scrolled window. If a child has native scrolling, use
--   <a>containerAdd</a> instead of this function.
--   
--   The viewport scrolls the child by moving its <a>Window</a>, and takes
--   the size of the child to be the size of its toplevel <a>Window</a>.
--   This will be very wrong for most widgets that support native
--   scrolling; for example, if you add a widget such as <a>TreeView</a>
--   with a viewport, the whole widget will scroll, including the column
--   headings. Thus, widgets with native scrolling support should not be
--   used with the <a>Viewport</a> proxy.
--   
--   A widget supports scrolling natively if it implements the
--   <a>Scrollable</a> interface.
scrolledWindowAddWithViewport :: (HasCallStack, MonadIO m, IsScrolledWindow a, IsWidget b) => a -> b -> m ()

-- | Return whether button presses are captured during kinetic scrolling.
--   See <a>scrolledWindowSetCaptureButtonPress</a>.
--   
--   <i>Since: 3.4</i>
scrolledWindowGetCaptureButtonPress :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Bool

-- | Returns the horizontal scrollbar of <i><tt>scrolledWindow</tt></i>.
--   
--   <i>Since: 2.8</i>
scrolledWindowGetHscrollbar :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Widget

-- | Returns the specified kinetic scrolling behavior.
--   
--   <i>Since: 3.4</i>
scrolledWindowGetKineticScrolling :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Bool

-- | Returns the maximum content height set.
--   
--   <i>Since: 3.22</i>
scrolledWindowGetMaxContentHeight :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Int32

-- | Returns the maximum content width set.
--   
--   <i>Since: 3.22</i>
scrolledWindowGetMaxContentWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Int32

-- | Gets the minimal content height of <i><tt>scrolledWindow</tt></i>, or
--   -1 if not set.
--   
--   <i>Since: 3.0</i>
scrolledWindowGetMinContentHeight :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Int32

-- | Gets the minimum content width of <i><tt>scrolledWindow</tt></i>, or
--   -1 if not set.
--   
--   <i>Since: 3.0</i>
scrolledWindowGetMinContentWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Int32

-- | Returns whether overlay scrolling is enabled for this scrolled window.
--   
--   <i>Since: 3.16</i>
scrolledWindowGetOverlayScrolling :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Bool

-- | Gets the placement of the contents with respect to the scrollbars for
--   the scrolled window. See <a>scrolledWindowSetPlacement</a>.
scrolledWindowGetPlacement :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m CornerType

-- | Retrieves the current policy values for the horizontal and vertical
--   scrollbars. See <a>scrolledWindowSetPolicy</a>.
scrolledWindowGetPolicy :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m (PolicyType, PolicyType)

-- | Reports whether the natural height of the child will be calculated and
--   propagated through the scrolled window’s requested natural height.
--   
--   <i>Since: 3.22</i>
scrolledWindowGetPropagateNaturalHeight :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Bool

-- | Reports whether the natural width of the child will be calculated and
--   propagated through the scrolled window’s requested natural width.
--   
--   <i>Since: 3.22</i>
scrolledWindowGetPropagateNaturalWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Bool

-- | Gets the shadow type of the scrolled window. See
--   <a>scrolledWindowSetShadowType</a>.
scrolledWindowGetShadowType :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m ShadowType

-- | Returns the vertical scrollbar of <i><tt>scrolledWindow</tt></i>.
--   
--   <i>Since: 2.8</i>
scrolledWindowGetVscrollbar :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Widget

-- | Changes the behaviour of <i><tt>scrolledWindow</tt></i> with regard to
--   the initial event that possibly starts kinetic scrolling. When
--   <i><tt>captureButtonPress</tt></i> is set to <a>True</a>, the event is
--   captured by the scrolled window, and then later replayed if it is
--   meant to go to the child widget.
--   
--   This should be enabled if any child widgets perform non-reversible
--   actions on <a>Widget::buttonPressEvent</a>. If they don't, and handle
--   additionally handle <a>Widget::grabBrokenEvent</a>, it might be better
--   to set <i><tt>captureButtonPress</tt></i> to <a>False</a>.
--   
--   This setting only has an effect if kinetic scrolling is enabled.
--   
--   <i>Since: 3.4</i>
scrolledWindowSetCaptureButtonPress :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Bool -> m ()

-- | Sets the <a>Adjustment</a> for the horizontal scrollbar.
scrolledWindowSetHadjustment :: (HasCallStack, MonadIO m, IsScrolledWindow a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Turns kinetic scrolling on or off. Kinetic scrolling only applies to
--   devices with source <a>InputSourceTouchscreen</a>.
--   
--   <i>Since: 3.4</i>
scrolledWindowSetKineticScrolling :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Bool -> m ()

-- | Sets the maximum height that <i><tt>scrolledWindow</tt></i> should
--   keep visible. The <i><tt>scrolledWindow</tt></i> will grow up to this
--   height before it starts scrolling the content.
--   
--   It is a programming error to set the maximum content height to a value
--   smaller than <a>ScrolledWindow:minContentHeight</a>.
--   
--   <i>Since: 3.22</i>
scrolledWindowSetMaxContentHeight :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Int32 -> m ()

-- | Sets the maximum width that <i><tt>scrolledWindow</tt></i> should keep
--   visible. The <i><tt>scrolledWindow</tt></i> will grow up to this width
--   before it starts scrolling the content.
--   
--   It is a programming error to set the maximum content width to a value
--   smaller than <a>ScrolledWindow:minContentWidth</a>.
--   
--   <i>Since: 3.22</i>
scrolledWindowSetMaxContentWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Int32 -> m ()

-- | Sets the minimum height that <i><tt>scrolledWindow</tt></i> should
--   keep visible. Note that this can and (usually will) be smaller than
--   the minimum size of the content.
--   
--   It is a programming error to set the minimum content height to a value
--   greater than <a>ScrolledWindow:maxContentHeight</a>.
--   
--   <i>Since: 3.0</i>
scrolledWindowSetMinContentHeight :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Int32 -> m ()

-- | Sets the minimum width that <i><tt>scrolledWindow</tt></i> should keep
--   visible. Note that this can and (usually will) be smaller than the
--   minimum size of the content.
--   
--   It is a programming error to set the minimum content width to a value
--   greater than <a>ScrolledWindow:maxContentWidth</a>.
--   
--   <i>Since: 3.0</i>
scrolledWindowSetMinContentWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Int32 -> m ()

-- | Enables or disables overlay scrolling for this scrolled window.
--   
--   <i>Since: 3.16</i>
scrolledWindowSetOverlayScrolling :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Bool -> m ()

-- | Sets the placement of the contents with respect to the scrollbars for
--   the scrolled window.
--   
--   The default is <a>CornerTypeTopLeft</a>, meaning the child is in the
--   top left, with the scrollbars underneath and to the right. Other
--   values in <a>CornerType</a> are <a>CornerTypeTopRight</a>,
--   <a>CornerTypeBottomLeft</a>, and <a>CornerTypeBottomRight</a>.
--   
--   See also <a>scrolledWindowGetPlacement</a> and
--   <a>scrolledWindowUnsetPlacement</a>.
scrolledWindowSetPlacement :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> CornerType -> m ()

-- | Sets the scrollbar policy for the horizontal and vertical scrollbars.
--   
--   The policy determines when the scrollbar should appear; it is a value
--   from the <a>PolicyType</a> enumeration. If <a>PolicyTypeAlways</a>,
--   the scrollbar is always present; if <a>PolicyTypeNever</a>, the
--   scrollbar is never present; if <a>PolicyTypeAutomatic</a>, the
--   scrollbar is present only if needed (that is, if the slider part of
--   the bar would be smaller than the trough — the display is larger than
--   the page size).
scrolledWindowSetPolicy :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> PolicyType -> PolicyType -> m ()

-- | Sets whether the natural height of the child should be calculated and
--   propagated through the scrolled window’s requested natural height.
--   
--   <i>Since: 3.22</i>
scrolledWindowSetPropagateNaturalHeight :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Bool -> m ()

-- | Sets whether the natural width of the child should be calculated and
--   propagated through the scrolled window’s requested natural width.
--   
--   <i>Since: 3.22</i>
scrolledWindowSetPropagateNaturalWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Bool -> m ()

-- | Changes the type of shadow drawn around the contents of
--   <i><tt>scrolledWindow</tt></i>.
scrolledWindowSetShadowType :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> ShadowType -> m ()

-- | Sets the <a>Adjustment</a> for the vertical scrollbar.
scrolledWindowSetVadjustment :: (HasCallStack, MonadIO m, IsScrolledWindow a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Unsets the placement of the contents with respect to the scrollbars
--   for the scrolled window. If no window placement is set for a scrolled
--   window, it defaults to <a>CornerTypeTopLeft</a>.
--   
--   See also <a>scrolledWindowSetPlacement</a> and
--   <a>scrolledWindowGetPlacement</a>.
--   
--   <i>Since: 2.10</i>
scrolledWindowUnsetPlacement :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m ()

-- | Cast to <a>Revealer</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toRevealer :: (MonadIO m, IsRevealer o) => o -> m Revealer

-- | Get the value of the “<tt>child-revealed</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> revealer #childRevealed
--   </pre>
getRevealerChildRevealed :: (MonadIO m, IsRevealer o) => o -> m Bool

-- | Get the value of the “<tt>reveal-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> revealer #revealChild
--   </pre>
getRevealerRevealChild :: (MonadIO m, IsRevealer o) => o -> m Bool

-- | Set the value of the “<tt>reveal-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> revealer [ #revealChild <a>:=</a> value ]
--   </pre>
setRevealerRevealChild :: (MonadIO m, IsRevealer o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>reveal-child</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructRevealerRevealChild :: (IsRevealer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>transition-duration</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> revealer #transitionDuration
--   </pre>
getRevealerTransitionDuration :: (MonadIO m, IsRevealer o) => o -> m Word32

-- | Set the value of the “<tt>transition-duration</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> revealer [ #transitionDuration <a>:=</a> value ]
--   </pre>
setRevealerTransitionDuration :: (MonadIO m, IsRevealer o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>transition-duration</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructRevealerTransitionDuration :: (IsRevealer o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>transition-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> revealer #transitionType
--   </pre>
getRevealerTransitionType :: (MonadIO m, IsRevealer o) => o -> m RevealerTransitionType

-- | Set the value of the “<tt>transition-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> revealer [ #transitionType <a>:=</a> value ]
--   </pre>
setRevealerTransitionType :: (MonadIO m, IsRevealer o) => o -> RevealerTransitionType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>transition-type</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructRevealerTransitionType :: (IsRevealer o, MonadIO m) => RevealerTransitionType -> m (GValueConstruct o)

-- | Creates a new <a>Revealer</a>.
--   
--   <i>Since: 3.10</i>
revealerNew :: (HasCallStack, MonadIO m) => m Revealer

-- | Returns whether the child is fully revealed, in other words whether
--   the transition to the revealed state is completed.
--   
--   <i>Since: 3.10</i>
revealerGetChildRevealed :: (HasCallStack, MonadIO m, IsRevealer a) => a -> m Bool

-- | Returns whether the child is currently revealed. See
--   <a>revealerSetRevealChild</a>.
--   
--   This function returns <a>True</a> as soon as the transition is to the
--   revealed state is started. To learn whether the child is fully
--   revealed (ie the transition is completed), use
--   <a>revealerGetChildRevealed</a>.
--   
--   <i>Since: 3.10</i>
revealerGetRevealChild :: (HasCallStack, MonadIO m, IsRevealer a) => a -> m Bool

-- | Returns the amount of time (in milliseconds) that transitions will
--   take.
--   
--   <i>Since: 3.10</i>
revealerGetTransitionDuration :: (HasCallStack, MonadIO m, IsRevealer a) => a -> m Word32

-- | Gets the type of animation that will be used for transitions in
--   <i><tt>revealer</tt></i>.
--   
--   <i>Since: 3.10</i>
revealerGetTransitionType :: (HasCallStack, MonadIO m, IsRevealer a) => a -> m RevealerTransitionType

-- | Tells the <a>Revealer</a> to reveal or conceal its child.
--   
--   The transition will be animated with the current transition type of
--   <i><tt>revealer</tt></i>.
--   
--   <i>Since: 3.10</i>
revealerSetRevealChild :: (HasCallStack, MonadIO m, IsRevealer a) => a -> Bool -> m ()

-- | Sets the duration that transitions will take.
--   
--   <i>Since: 3.10</i>
revealerSetTransitionDuration :: (HasCallStack, MonadIO m, IsRevealer a) => a -> Word32 -> m ()

-- | Sets the type of animation that will be used for transitions in
--   <i><tt>revealer</tt></i>. Available types include various kinds of
--   fades and slides.
--   
--   <i>Since: 3.10</i>
revealerSetTransitionType :: (HasCallStack, MonadIO m, IsRevealer a) => a -> RevealerTransitionType -> m ()

-- | Cast to <a>RecentFilter</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toRecentFilter :: (MonadIO m, IsRecentFilter o) => o -> m RecentFilter

-- | Creates a new <a>RecentFilter</a> with no rules added to it. Such
--   filter does not accept any recently used resources, so is not
--   particularly useful until you add rules with
--   <a>recentFilterAddPattern</a>, <a>recentFilterAddMimeType</a>,
--   <a>recentFilterAddApplication</a>, <a>recentFilterAddAge</a>. To
--   create a filter that accepts any recently used resource, use:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GtkRecentFilter *filter = gtk_recent_filter_new ();
--   gtk_recent_filter_add_pattern (filter, "*");
--   </pre>
--   
--   <i>Since: 2.10</i>
recentFilterNew :: (HasCallStack, MonadIO m) => m RecentFilter

-- | Adds a rule that allows resources based on their age - that is, the
--   number of days elapsed since they were last modified.
--   
--   <i>Since: 2.10</i>
recentFilterAddAge :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> Int32 -> m ()

-- | Adds a rule that allows resources based on the name of the application
--   that has registered them.
--   
--   <i>Since: 2.10</i>
recentFilterAddApplication :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> Text -> m ()

-- | Adds a rule that allows resources based on the name of the group to
--   which they belong
--   
--   <i>Since: 2.10</i>
recentFilterAddGroup :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> Text -> m ()

-- | Adds a rule that allows resources based on their registered MIME type.
--   
--   <i>Since: 2.10</i>
recentFilterAddMimeType :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> Text -> m ()

-- | Adds a rule that allows resources based on a pattern matching their
--   display name.
--   
--   <i>Since: 2.10</i>
recentFilterAddPattern :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> Text -> m ()

-- | Adds a rule allowing image files in the formats supported by
--   GdkPixbuf.
--   
--   <i>Since: 2.10</i>
recentFilterAddPixbufFormats :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> m ()

-- | Tests whether a file should be displayed according to
--   <i><tt>filter</tt></i>. The <a>RecentFilterInfo</a>
--   <i><tt>filterInfo</tt></i> should include the fields returned from
--   <a>recentFilterGetNeeded</a>, and must set the
--   <a>RecentFilterInfo</a>.<tt><i>contains</i></tt> field of
--   <i><tt>filterInfo</tt></i> to indicate which fields have been set.
--   
--   This function will not typically be used by applications; it is
--   intended principally for use in the implementation of
--   <a>RecentChooser</a>.
--   
--   <i>Since: 2.10</i>
recentFilterFilter :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> RecentFilterInfo -> m Bool

-- | Gets the human-readable name for the filter. See
--   <a>recentFilterSetName</a>.
--   
--   <i>Since: 2.10</i>
recentFilterGetName :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> m (Maybe Text)

-- | Gets the fields that need to be filled in for the
--   <a>RecentFilterInfo</a> passed to <a>recentFilterFilter</a>
--   
--   This function will not typically be used by applications; it is
--   intended principally for use in the implementation of
--   <a>RecentChooser</a>.
--   
--   <i>Since: 2.10</i>
recentFilterGetNeeded :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> m [RecentFilterFlags]

-- | Sets the human-readable name of the filter; this is the string that
--   will be displayed in the recently used resources selector user
--   interface if there is a selectable list of filters.
--   
--   <i>Since: 2.10</i>
recentFilterSetName :: (HasCallStack, MonadIO m, IsRecentFilter a) => a -> Text -> m ()

-- | Cast to <a>Range</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toRange :: (MonadIO m, IsRange o) => o -> m Range

-- | Connect a signal handler for the <a>adjustBounds</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> range #adjustBounds callback
--   </pre>
onRangeAdjustBounds :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeAdjustBoundsCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>adjustBounds</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> range #adjustBounds callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterRangeAdjustBounds :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeAdjustBoundsCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changeValue</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> range #changeValue callback
--   </pre>
onRangeChangeValue :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeChangeValueCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changeValue</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> range #changeValue callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterRangeChangeValue :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeChangeValueCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveSlider</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> range #moveSlider callback
--   </pre>
onRangeMoveSlider :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeMoveSliderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveSlider</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> range #moveSlider callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterRangeMoveSlider :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeMoveSliderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>valueChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> range #valueChanged callback
--   </pre>
onRangeValueChanged :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeValueChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>valueChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> range #valueChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterRangeValueChanged :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeValueChangedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> range #adjustment
--   </pre>
getRangeAdjustment :: (MonadIO m, IsRange o) => o -> m Adjustment

-- | Set the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> range [ #adjustment <a>:=</a> value ]
--   </pre>
setRangeAdjustment :: (MonadIO m, IsRange o, IsAdjustment a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>adjustment</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructRangeAdjustment :: (IsRange o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>fill-level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> range #fillLevel
--   </pre>
getRangeFillLevel :: (MonadIO m, IsRange o) => o -> m Double

-- | Set the value of the “<tt>fill-level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> range [ #fillLevel <a>:=</a> value ]
--   </pre>
setRangeFillLevel :: (MonadIO m, IsRange o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fill-level</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructRangeFillLevel :: (IsRange o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> range #inverted
--   </pre>
getRangeInverted :: (MonadIO m, IsRange o) => o -> m Bool

-- | Set the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> range [ #inverted <a>:=</a> value ]
--   </pre>
setRangeInverted :: (MonadIO m, IsRange o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inverted</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructRangeInverted :: (IsRange o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>lower-stepper-sensitivity</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> range #lowerStepperSensitivity
--   </pre>
getRangeLowerStepperSensitivity :: (MonadIO m, IsRange o) => o -> m SensitivityType

-- | Set the value of the “<tt>lower-stepper-sensitivity</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> range [ #lowerStepperSensitivity <a>:=</a> value ]
--   </pre>
setRangeLowerStepperSensitivity :: (MonadIO m, IsRange o) => o -> SensitivityType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>lower-stepper-sensitivity</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructRangeLowerStepperSensitivity :: (IsRange o, MonadIO m) => SensitivityType -> m (GValueConstruct o)

-- | Get the value of the “<tt>restrict-to-fill-level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> range #restrictToFillLevel
--   </pre>
getRangeRestrictToFillLevel :: (MonadIO m, IsRange o) => o -> m Bool

-- | Set the value of the “<tt>restrict-to-fill-level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> range [ #restrictToFillLevel <a>:=</a> value ]
--   </pre>
setRangeRestrictToFillLevel :: (MonadIO m, IsRange o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>restrict-to-fill-level</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructRangeRestrictToFillLevel :: (IsRange o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>round-digits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> range #roundDigits
--   </pre>
getRangeRoundDigits :: (MonadIO m, IsRange o) => o -> m Int32

-- | Set the value of the “<tt>round-digits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> range [ #roundDigits <a>:=</a> value ]
--   </pre>
setRangeRoundDigits :: (MonadIO m, IsRange o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>round-digits</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructRangeRoundDigits :: (IsRange o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-fill-level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> range #showFillLevel
--   </pre>
getRangeShowFillLevel :: (MonadIO m, IsRange o) => o -> m Bool

-- | Set the value of the “<tt>show-fill-level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> range [ #showFillLevel <a>:=</a> value ]
--   </pre>
setRangeShowFillLevel :: (MonadIO m, IsRange o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-fill-level</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructRangeShowFillLevel :: (IsRange o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>upper-stepper-sensitivity</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> range #upperStepperSensitivity
--   </pre>
getRangeUpperStepperSensitivity :: (MonadIO m, IsRange o) => o -> m SensitivityType

-- | Set the value of the “<tt>upper-stepper-sensitivity</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> range [ #upperStepperSensitivity <a>:=</a> value ]
--   </pre>
setRangeUpperStepperSensitivity :: (MonadIO m, IsRange o) => o -> SensitivityType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>upper-stepper-sensitivity</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructRangeUpperStepperSensitivity :: (IsRange o, MonadIO m) => SensitivityType -> m (GValueConstruct o)

-- | Gets the current position of the fill level indicator.
--   
--   <i>Since: 2.12</i>
rangeGetFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> m Double

-- | Gets the value set by <a>rangeSetFlippable</a>.
--   
--   <i>Since: 2.18</i>
rangeGetFlippable :: (HasCallStack, MonadIO m, IsRange a) => a -> m Bool

-- | Gets the value set by <a>rangeSetInverted</a>.
rangeGetInverted :: (HasCallStack, MonadIO m, IsRange a) => a -> m Bool

-- | Gets the sensitivity policy for the stepper that points to the 'lower'
--   end of the GtkRange’s adjustment.
--   
--   <i>Since: 2.10</i>
rangeGetLowerStepperSensitivity :: (HasCallStack, MonadIO m, IsRange a) => a -> m SensitivityType

-- | This function is useful mainly for <a>Range</a> subclasses.
--   
--   See <a>rangeSetMinSliderSize</a>.
--   
--   <i>Since: 2.20</i>
rangeGetMinSliderSize :: (HasCallStack, MonadIO m, IsRange a) => a -> m Int32

-- | This function returns the area that contains the range’s trough and
--   its steppers, in widget-&gt;window coordinates.
--   
--   This function is useful mainly for <a>Range</a> subclasses.
--   
--   <i>Since: 2.20</i>
rangeGetRangeRect :: (HasCallStack, MonadIO m, IsRange a) => a -> m Rectangle

-- | Gets whether the range is restricted to the fill level.
--   
--   <i>Since: 2.12</i>
rangeGetRestrictToFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> m Bool

-- | Gets the number of digits to round the value to when it changes. See
--   <a>Range::changeValue</a>.
--   
--   <i>Since: 2.24</i>
rangeGetRoundDigits :: (HasCallStack, MonadIO m, IsRange a) => a -> m Int32

-- | Gets whether the range displays the fill level graphically.
--   
--   <i>Since: 2.12</i>
rangeGetShowFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> m Bool

-- | This function returns sliders range along the long dimension, in
--   widget-&gt;window coordinates.
--   
--   This function is useful mainly for <a>Range</a> subclasses.
--   
--   <i>Since: 2.20</i>
rangeGetSliderRange :: (HasCallStack, MonadIO m, IsRange a) => a -> m (Int32, Int32)

-- | This function is useful mainly for <a>Range</a> subclasses.
--   
--   See <a>rangeSetSliderSizeFixed</a>.
--   
--   <i>Since: 2.20</i>
rangeGetSliderSizeFixed :: (HasCallStack, MonadIO m, IsRange a) => a -> m Bool

-- | Gets the sensitivity policy for the stepper that points to the 'upper'
--   end of the GtkRange’s adjustment.
--   
--   <i>Since: 2.10</i>
rangeGetUpperStepperSensitivity :: (HasCallStack, MonadIO m, IsRange a) => a -> m SensitivityType

-- | Gets the current value of the range.
rangeGetValue :: (HasCallStack, MonadIO m, IsRange a) => a -> m Double

-- | Set the new position of the fill level indicator.
--   
--   The “fill level” is probably best described by its most prominent use
--   case, which is an indicator for the amount of pre-buffering in a
--   streaming media player. In that use case, the value of the range would
--   indicate the current play position, and the fill level would be the
--   position up to which the file/stream has been downloaded.
--   
--   This amount of prebuffering can be displayed on the range’s trough and
--   is themeable separately from the trough. To enable fill level display,
--   use <a>rangeSetShowFillLevel</a>. The range defaults to not showing
--   the fill level.
--   
--   Additionally, it’s possible to restrict the range’s slider position to
--   values which are smaller than the fill level. This is controller by
--   <a>rangeSetRestrictToFillLevel</a> and is by default enabled.
--   
--   <i>Since: 2.12</i>
rangeSetFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> Double -> m ()

-- | If a range is flippable, it will switch its direction if it is
--   horizontal and its direction is <a>TextDirectionRtl</a>.
--   
--   See <a>widgetGetDirection</a>.
--   
--   <i>Since: 2.18</i>
rangeSetFlippable :: (HasCallStack, MonadIO m, IsRange a) => a -> Bool -> m ()

-- | Sets the step and page sizes for the range. The step size is used when
--   the user clicks the <a>Scrollbar</a> arrows or moves <a>Scale</a> via
--   arrow keys. The page size is used for example when moving via Page Up
--   or Page Down keys.
rangeSetIncrements :: (HasCallStack, MonadIO m, IsRange a) => a -> Double -> Double -> m ()

-- | Ranges normally move from lower to higher values as the slider moves
--   from top to bottom or left to right. Inverted ranges have higher
--   values at the top or on the right rather than on the bottom or left.
rangeSetInverted :: (HasCallStack, MonadIO m, IsRange a) => a -> Bool -> m ()

-- | Sets the sensitivity policy for the stepper that points to the 'lower'
--   end of the GtkRange’s adjustment.
--   
--   <i>Since: 2.10</i>
rangeSetLowerStepperSensitivity :: (HasCallStack, MonadIO m, IsRange a) => a -> SensitivityType -> m ()

-- | Sets the minimum size of the range’s slider.
--   
--   This function is useful mainly for <a>Range</a> subclasses.
--   
--   <i>Since: 2.20</i>
rangeSetMinSliderSize :: (HasCallStack, MonadIO m, IsRange a) => a -> Int32 -> m ()

-- | Sets the allowable values in the <a>Range</a>, and clamps the range
--   value to be between <i><tt>min</tt></i> and <i><tt>max</tt></i>. (If
--   the range has a non-zero page size, it is clamped between
--   <i><tt>min</tt></i> and <i><tt>max</tt></i> - page-size.)
rangeSetRange :: (HasCallStack, MonadIO m, IsRange a) => a -> Double -> Double -> m ()

-- | Sets whether the slider is restricted to the fill level. See
--   <a>rangeSetFillLevel</a> for a general description of the fill level
--   concept.
--   
--   <i>Since: 2.12</i>
rangeSetRestrictToFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> Bool -> m ()

-- | Sets the number of digits to round the value to when it changes. See
--   <a>Range::changeValue</a>.
--   
--   <i>Since: 2.24</i>
rangeSetRoundDigits :: (HasCallStack, MonadIO m, IsRange a) => a -> Int32 -> m ()

-- | Sets whether a graphical fill level is show on the trough. See
--   <a>rangeSetFillLevel</a> for a general description of the fill level
--   concept.
--   
--   <i>Since: 2.12</i>
rangeSetShowFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> Bool -> m ()

-- | Sets whether the range’s slider has a fixed size, or a size that
--   depends on its adjustment’s page size.
--   
--   This function is useful mainly for <a>Range</a> subclasses.
--   
--   <i>Since: 2.20</i>
rangeSetSliderSizeFixed :: (HasCallStack, MonadIO m, IsRange a) => a -> Bool -> m ()

-- | Sets the sensitivity policy for the stepper that points to the 'upper'
--   end of the GtkRange’s adjustment.
--   
--   <i>Since: 2.10</i>
rangeSetUpperStepperSensitivity :: (HasCallStack, MonadIO m, IsRange a) => a -> SensitivityType -> m ()

-- | Sets the current value of the range; if the value is outside the
--   minimum or maximum range values, it will be clamped to fit inside
--   them. The range emits the <a>Range::valueChanged</a> signal if the
--   value changes.
rangeSetValue :: (HasCallStack, MonadIO m, IsRange a) => a -> Double -> m ()

-- | Cast to <a>Scrollbar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toScrollbar :: (MonadIO m, IsScrollbar o) => o -> m Scrollbar

-- | Creates a new scrollbar with the given orientation.
--   
--   <i>Since: 3.0</i>
scrollbarNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Orientation -> Maybe a -> m Scrollbar

-- | Cast to <a>VScrollbar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toVScrollbar :: (MonadIO m, IsVScrollbar o) => o -> m VScrollbar

-- | Creates a new vertical scrollbar.
vScrollbarNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe a -> m VScrollbar

-- | Cast to <a>Scale</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toScale :: (MonadIO m, IsScale o) => o -> m Scale

-- | Connect a signal handler for the <a>formatValue</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> scale #formatValue callback
--   </pre>
onScaleFormatValue :: (IsScale a, MonadIO m) => a -> ((?self :: a) => ScaleFormatValueCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>formatValue</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> scale #formatValue callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterScaleFormatValue :: (IsScale a, MonadIO m) => a -> ((?self :: a) => ScaleFormatValueCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>digits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scale #digits
--   </pre>
getScaleDigits :: (MonadIO m, IsScale o) => o -> m Int32

-- | Set the value of the “<tt>digits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scale [ #digits <a>:=</a> value ]
--   </pre>
setScaleDigits :: (MonadIO m, IsScale o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>digits</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructScaleDigits :: (IsScale o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>draw-value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scale #drawValue
--   </pre>
getScaleDrawValue :: (MonadIO m, IsScale o) => o -> m Bool

-- | Set the value of the “<tt>draw-value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scale [ #drawValue <a>:=</a> value ]
--   </pre>
setScaleDrawValue :: (MonadIO m, IsScale o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>draw-value</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructScaleDrawValue :: (IsScale o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-origin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scale #hasOrigin
--   </pre>
getScaleHasOrigin :: (MonadIO m, IsScale o) => o -> m Bool

-- | Set the value of the “<tt>has-origin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scale [ #hasOrigin <a>:=</a> value ]
--   </pre>
setScaleHasOrigin :: (MonadIO m, IsScale o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-origin</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructScaleHasOrigin :: (IsScale o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>value-pos</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scale #valuePos
--   </pre>
getScaleValuePos :: (MonadIO m, IsScale o) => o -> m PositionType

-- | Set the value of the “<tt>value-pos</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scale [ #valuePos <a>:=</a> value ]
--   </pre>
setScaleValuePos :: (MonadIO m, IsScale o) => o -> PositionType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>value-pos</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructScaleValuePos :: (IsScale o, MonadIO m) => PositionType -> m (GValueConstruct o)

-- | Creates a new <a>Scale</a>.
--   
--   <i>Since: 3.0</i>
scaleNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Orientation -> Maybe a -> m Scale

-- | Creates a new scale widget with the given orientation that lets the
--   user input a number between <i><tt>min</tt></i> and
--   <i><tt>max</tt></i> (including <i><tt>min</tt></i> and
--   <i><tt>max</tt></i>) with the increment <i><tt>step</tt></i>.
--   <i><tt>step</tt></i> must be nonzero; it’s the distance the slider
--   moves when using the arrow keys to adjust the scale value.
--   
--   Note that the way in which the precision is derived works best if
--   <i><tt>step</tt></i> is a power of ten. If the resulting precision is
--   not suitable for your needs, use <a>scaleSetDigits</a> to correct it.
--   
--   <i>Since: 3.0</i>
scaleNewWithRange :: (HasCallStack, MonadIO m) => Orientation -> Double -> Double -> Double -> m Scale

-- | Adds a mark at <i><tt>value</tt></i>.
--   
--   A mark is indicated visually by drawing a tick mark next to the scale,
--   and GTK+ makes it easy for the user to position the scale exactly at
--   the marks value.
--   
--   If <i><tt>markup</tt></i> is not <a>Nothing</a>, text is shown next to
--   the tick mark.
--   
--   To remove marks from a scale, use <a>scaleClearMarks</a>.
--   
--   <i>Since: 2.16</i>
scaleAddMark :: (HasCallStack, MonadIO m, IsScale a) => a -> Double -> PositionType -> Maybe Text -> m ()

-- | Removes any marks that have been added with <a>scaleAddMark</a>.
--   
--   <i>Since: 2.16</i>
scaleClearMarks :: (HasCallStack, MonadIO m, IsScale a) => a -> m ()

-- | Gets the number of decimal places that are displayed in the value.
scaleGetDigits :: (HasCallStack, MonadIO m, IsScale a) => a -> m Int32

-- | Returns whether the current value is displayed as a string next to the
--   slider.
scaleGetDrawValue :: (HasCallStack, MonadIO m, IsScale a) => a -> m Bool

-- | Returns whether the scale has an origin.
--   
--   <i>Since: 3.4</i>
scaleGetHasOrigin :: (HasCallStack, MonadIO m, IsScale a) => a -> m Bool

-- | Gets the <a>Layout</a> used to display the scale. The returned object
--   is owned by the scale so does not need to be freed by the caller.
--   
--   <i>Since: 2.4</i>
scaleGetLayout :: (HasCallStack, MonadIO m, IsScale a) => a -> m (Maybe Layout)

-- | Obtains the coordinates where the scale will draw the <a>Layout</a>
--   representing the text in the scale. Remember when using the
--   <a>Layout</a> function you need to convert to and from pixels using
--   <tt><i>PANGO_PIXELS()</i></tt> or <a>SCALE</a>.
--   
--   If the <a>Scale:drawValue</a> property is <a>False</a>, the return
--   values are undefined.
--   
--   <i>Since: 2.4</i>
scaleGetLayoutOffsets :: (HasCallStack, MonadIO m, IsScale a) => a -> m (Int32, Int32)

-- | Gets the position in which the current value is displayed.
scaleGetValuePos :: (HasCallStack, MonadIO m, IsScale a) => a -> m PositionType

-- | Specifies whether the current value is displayed as a string next to
--   the slider.
scaleSetDrawValue :: (HasCallStack, MonadIO m, IsScale a) => a -> Bool -> m ()

-- | If <a>Scale:hasOrigin</a> is set to <a>True</a> (the default), the
--   scale will highlight the part of the trough between the origin (bottom
--   or left side) and the current value.
--   
--   <i>Since: 3.4</i>
scaleSetHasOrigin :: (HasCallStack, MonadIO m, IsScale a) => a -> Bool -> m ()

-- | Sets the position in which the current value is displayed.
scaleSetValuePos :: (HasCallStack, MonadIO m, IsScale a) => a -> PositionType -> m ()

-- | Cast to <a>VScale</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toVScale :: (MonadIO m, IsVScale o) => o -> m VScale

-- | Creates a new <a>VScale</a>.
vScaleNew :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m VScale

-- | Creates a new vertical scale widget that lets the user input a number
--   between <i><tt>min</tt></i> and <i><tt>max</tt></i> (including
--   <i><tt>min</tt></i> and <i><tt>max</tt></i>) with the increment
--   <i><tt>step</tt></i>. <i><tt>step</tt></i> must be nonzero; it’s the
--   distance the slider moves when using the arrow keys to adjust the
--   scale value.
--   
--   Note that the way in which the precision is derived works best if
--   <i><tt>step</tt></i> is a power of ten. If the resulting precision is
--   not suitable for your needs, use <a>scaleSetDigits</a> to correct it.
vScaleNewWithRange :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> m VScale

-- | Cast to <a>ProgressBar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toProgressBar :: (MonadIO m, IsProgressBar o) => o -> m ProgressBar

-- | Get the value of the “<tt>ellipsize</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> progressBar #ellipsize
--   </pre>
getProgressBarEllipsize :: (MonadIO m, IsProgressBar o) => o -> m EllipsizeMode

-- | Set the value of the “<tt>ellipsize</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> progressBar [ #ellipsize <a>:=</a> value ]
--   </pre>
setProgressBarEllipsize :: (MonadIO m, IsProgressBar o) => o -> EllipsizeMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ellipsize</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructProgressBarEllipsize :: (IsProgressBar o, MonadIO m) => EllipsizeMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>fraction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> progressBar #fraction
--   </pre>
getProgressBarFraction :: (MonadIO m, IsProgressBar o) => o -> m Double

-- | Set the value of the “<tt>fraction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> progressBar [ #fraction <a>:=</a> value ]
--   </pre>
setProgressBarFraction :: (MonadIO m, IsProgressBar o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fraction</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructProgressBarFraction :: (IsProgressBar o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> progressBar #inverted
--   </pre>
getProgressBarInverted :: (MonadIO m, IsProgressBar o) => o -> m Bool

-- | Set the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> progressBar [ #inverted <a>:=</a> value ]
--   </pre>
setProgressBarInverted :: (MonadIO m, IsProgressBar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inverted</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructProgressBarInverted :: (IsProgressBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>pulse-step</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> progressBar #pulseStep
--   </pre>
getProgressBarPulseStep :: (MonadIO m, IsProgressBar o) => o -> m Double

-- | Set the value of the “<tt>pulse-step</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> progressBar [ #pulseStep <a>:=</a> value ]
--   </pre>
setProgressBarPulseStep :: (MonadIO m, IsProgressBar o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pulse-step</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructProgressBarPulseStep :: (IsProgressBar o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> progressBar #showText
--   </pre>
getProgressBarShowText :: (MonadIO m, IsProgressBar o) => o -> m Bool

-- | Set the value of the “<tt>show-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> progressBar [ #showText <a>:=</a> value ]
--   </pre>
setProgressBarShowText :: (MonadIO m, IsProgressBar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-text</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructProgressBarShowText :: (IsProgressBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> progressBar #text
--   </pre>
getProgressBarText :: (MonadIO m, IsProgressBar o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> progressBar [ #text <a>:=</a> value ]
--   </pre>
setProgressBarText :: (MonadIO m, IsProgressBar o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructProgressBarText :: (IsProgressBar o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>text</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #text
--   </pre>
clearProgressBarText :: (MonadIO m, IsProgressBar o) => o -> m ()

-- | Creates a new <a>ProgressBar</a>.
progressBarNew :: (HasCallStack, MonadIO m) => m ProgressBar

-- | Returns the ellipsizing position of the progress bar. See
--   <a>progressBarSetEllipsize</a>.
--   
--   <i>Since: 2.6</i>
progressBarGetEllipsize :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m EllipsizeMode

-- | Returns the current fraction of the task that’s been completed.
progressBarGetFraction :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m Double

-- | Gets the value set by <a>progressBarSetInverted</a>.
progressBarGetInverted :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m Bool

-- | Retrieves the pulse step set with <a>progressBarSetPulseStep</a>.
progressBarGetPulseStep :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m Double

-- | Gets the value of the <a>ProgressBar:showText</a> property. See
--   <a>progressBarSetShowText</a>.
--   
--   <i>Since: 3.0</i>
progressBarGetShowText :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m Bool

-- | Retrieves the text that is displayed with the progress bar, if any,
--   otherwise <a>Nothing</a>. The return value is a reference to the text,
--   not a copy of it, so will become invalid if you change the text in the
--   progress bar.
progressBarGetText :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m (Maybe Text)

-- | Indicates that some progress has been made, but you don’t know how
--   much. Causes the progress bar to enter “activity mode,” where a block
--   bounces back and forth. Each call to <a>progressBarPulse</a> causes
--   the block to move by a little bit (the amount of movement per pulse is
--   determined by <a>progressBarSetPulseStep</a>).
progressBarPulse :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m ()

-- | Sets the mode used to ellipsize (add an ellipsis: "...") the text if
--   there is not enough space to render the entire string.
--   
--   <i>Since: 2.6</i>
progressBarSetEllipsize :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> EllipsizeMode -> m ()

-- | Causes the progress bar to “fill in” the given fraction of the bar.
--   The fraction should be between 0.0 and 1.0, inclusive.
progressBarSetFraction :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> Double -> m ()

-- | Progress bars normally grow from top to bottom or left to right.
--   Inverted progress bars grow in the opposite direction.
progressBarSetInverted :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> Bool -> m ()

-- | Sets the fraction of total progress bar length to move the bouncing
--   block for each call to <a>progressBarPulse</a>.
progressBarSetPulseStep :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> Double -> m ()

-- | Sets whether the progress bar will show text next to the bar. The
--   shown text is either the value of the <a>ProgressBar:text</a> property
--   or, if that is <a>Nothing</a>, the <a>ProgressBar:fraction</a> value,
--   as a percentage.
--   
--   To make a progress bar that is styled and sized suitably for
--   containing text (even if the actual text is blank), set
--   <a>ProgressBar:showText</a> to <a>True</a> and <a>ProgressBar:text</a>
--   to the empty string (not <a>Nothing</a>).
--   
--   <i>Since: 3.0</i>
progressBarSetShowText :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> Bool -> m ()

-- | Causes the given <i><tt>text</tt></i> to appear next to the progress
--   bar.
--   
--   If <i><tt>text</tt></i> is <a>Nothing</a> and
--   <a>ProgressBar:showText</a> is <a>True</a>, the current value of
--   <a>ProgressBar:fraction</a> will be displayed as a percentage.
--   
--   If <i><tt>text</tt></i> is non-<a>Nothing</a> and
--   <a>ProgressBar:showText</a> is <a>True</a>, the text will be
--   displayed. In this case, it will not display the progress percentage.
--   If <i><tt>text</tt></i> is the empty string, the progress bar will
--   still be styled and sized suitably for containing text, as long as
--   <a>ProgressBar:showText</a> is <a>True</a>.
progressBarSetText :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> Maybe Text -> m ()

-- | Cast to <a>PrintOperation</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPrintOperation :: (MonadIO m, IsPrintOperation o) => o -> m PrintOperation

-- | Connect a signal handler for the <a>beginPrint</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #beginPrint callback
--   </pre>
onPrintOperationBeginPrint :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationBeginPrintCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>beginPrint</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #beginPrint callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationBeginPrint :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationBeginPrintCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>createCustomWidget</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #createCustomWidget callback
--   </pre>
onPrintOperationCreateCustomWidget :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationCreateCustomWidgetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>createCustomWidget</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #createCustomWidget callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationCreateCustomWidget :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationCreateCustomWidgetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>customWidgetApply</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #customWidgetApply callback
--   </pre>
onPrintOperationCustomWidgetApply :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationCustomWidgetApplyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>customWidgetApply</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #customWidgetApply callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationCustomWidgetApply :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationCustomWidgetApplyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>done</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #done callback
--   </pre>
onPrintOperationDone :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>done</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #done callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationDone :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>drawPage</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #drawPage callback
--   </pre>
onPrintOperationDrawPage :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationDrawPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>drawPage</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #drawPage callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationDrawPage :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationDrawPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>endPrint</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #endPrint callback
--   </pre>
onPrintOperationEndPrint :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationEndPrintCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>endPrint</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #endPrint callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationEndPrint :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationEndPrintCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>paginate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #paginate callback
--   </pre>
onPrintOperationPaginate :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationPaginateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>paginate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #paginate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationPaginate :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationPaginateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preview</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #preview callback
--   </pre>
onPrintOperationPreview :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preview</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #preview callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationPreview :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>requestPageSetup</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #requestPageSetup callback
--   </pre>
onPrintOperationRequestPageSetup :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationRequestPageSetupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>requestPageSetup</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #requestPageSetup callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationRequestPageSetup :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationRequestPageSetupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>statusChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #statusChanged callback
--   </pre>
onPrintOperationStatusChanged :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationStatusChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>statusChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #statusChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationStatusChanged :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationStatusChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>updateCustomWidget</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #updateCustomWidget callback
--   </pre>
onPrintOperationUpdateCustomWidget :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationUpdateCustomWidgetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>updateCustomWidget</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #updateCustomWidget callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationUpdateCustomWidget :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationUpdateCustomWidgetCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>allow-async</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #allowAsync
--   </pre>
getPrintOperationAllowAsync :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “<tt>allow-async</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #allowAsync <a>:=</a> value ]
--   </pre>
setPrintOperationAllowAsync :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>allow-async</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPrintOperationAllowAsync :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>current-page</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #currentPage
--   </pre>
getPrintOperationCurrentPage :: (MonadIO m, IsPrintOperation o) => o -> m Int32

-- | Set the value of the “<tt>current-page</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #currentPage <a>:=</a> value ]
--   </pre>
setPrintOperationCurrentPage :: (MonadIO m, IsPrintOperation o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>current-page</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPrintOperationCurrentPage :: (IsPrintOperation o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>custom-tab-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #customTabLabel
--   </pre>
getPrintOperationCustomTabLabel :: (MonadIO m, IsPrintOperation o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>custom-tab-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #customTabLabel <a>:=</a> value ]
--   </pre>
setPrintOperationCustomTabLabel :: (MonadIO m, IsPrintOperation o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>custom-tab-label</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPrintOperationCustomTabLabel :: (IsPrintOperation o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>custom-tab-label</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #customTabLabel
--   </pre>
clearPrintOperationCustomTabLabel :: (MonadIO m, IsPrintOperation o) => o -> m ()

-- | Get the value of the “<tt>default-page-setup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #defaultPageSetup
--   </pre>
getPrintOperationDefaultPageSetup :: (MonadIO m, IsPrintOperation o) => o -> m PageSetup

-- | Set the value of the “<tt>default-page-setup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #defaultPageSetup <a>:=</a> value ]
--   </pre>
setPrintOperationDefaultPageSetup :: (MonadIO m, IsPrintOperation o, IsPageSetup a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>default-page-setup</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructPrintOperationDefaultPageSetup :: (IsPrintOperation o, MonadIO m, IsPageSetup a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>default-page-setup</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #defaultPageSetup
--   </pre>
clearPrintOperationDefaultPageSetup :: (MonadIO m, IsPrintOperation o) => o -> m ()

-- | Get the value of the “<tt>embed-page-setup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #embedPageSetup
--   </pre>
getPrintOperationEmbedPageSetup :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “<tt>embed-page-setup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #embedPageSetup <a>:=</a> value ]
--   </pre>
setPrintOperationEmbedPageSetup :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>embed-page-setup</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPrintOperationEmbedPageSetup :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>export-filename</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #exportFilename
--   </pre>
getPrintOperationExportFilename :: (MonadIO m, IsPrintOperation o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>export-filename</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #exportFilename <a>:=</a> value ]
--   </pre>
setPrintOperationExportFilename :: (MonadIO m, IsPrintOperation o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>export-filename</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPrintOperationExportFilename :: (IsPrintOperation o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>export-filename</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #exportFilename
--   </pre>
clearPrintOperationExportFilename :: (MonadIO m, IsPrintOperation o) => o -> m ()

-- | Get the value of the “<tt>has-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #hasSelection
--   </pre>
getPrintOperationHasSelection :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “<tt>has-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #hasSelection <a>:=</a> value ]
--   </pre>
setPrintOperationHasSelection :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-selection</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPrintOperationHasSelection :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>job-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #jobName
--   </pre>
getPrintOperationJobName :: (MonadIO m, IsPrintOperation o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>job-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #jobName <a>:=</a> value ]
--   </pre>
setPrintOperationJobName :: (MonadIO m, IsPrintOperation o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>job-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPrintOperationJobName :: (IsPrintOperation o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>n-pages</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #nPages
--   </pre>
getPrintOperationNPages :: (MonadIO m, IsPrintOperation o) => o -> m Int32

-- | Set the value of the “<tt>n-pages</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #nPages <a>:=</a> value ]
--   </pre>
setPrintOperationNPages :: (MonadIO m, IsPrintOperation o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>n-pages</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPrintOperationNPages :: (IsPrintOperation o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>n-pages-to-print</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #nPagesToPrint
--   </pre>
getPrintOperationNPagesToPrint :: (MonadIO m, IsPrintOperation o) => o -> m Int32

-- | Get the value of the “<tt>print-settings</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #printSettings
--   </pre>
getPrintOperationPrintSettings :: (MonadIO m, IsPrintOperation o) => o -> m PrintSettings

-- | Set the value of the “<tt>print-settings</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #printSettings <a>:=</a> value ]
--   </pre>
setPrintOperationPrintSettings :: (MonadIO m, IsPrintOperation o, IsPrintSettings a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>print-settings</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPrintOperationPrintSettings :: (IsPrintOperation o, MonadIO m, IsPrintSettings a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>print-settings</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #printSettings
--   </pre>
clearPrintOperationPrintSettings :: (MonadIO m, IsPrintOperation o) => o -> m ()

-- | Get the value of the “<tt>show-progress</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #showProgress
--   </pre>
getPrintOperationShowProgress :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “<tt>show-progress</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #showProgress <a>:=</a> value ]
--   </pre>
setPrintOperationShowProgress :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-progress</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPrintOperationShowProgress :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>status</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #status
--   </pre>
getPrintOperationStatus :: (MonadIO m, IsPrintOperation o) => o -> m PrintStatus

-- | Get the value of the “<tt>status-string</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #statusString
--   </pre>
getPrintOperationStatusString :: (MonadIO m, IsPrintOperation o) => o -> m Text

-- | Get the value of the “<tt>support-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #supportSelection
--   </pre>
getPrintOperationSupportSelection :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “<tt>support-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #supportSelection <a>:=</a> value ]
--   </pre>
setPrintOperationSupportSelection :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>support-selection</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPrintOperationSupportSelection :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>track-print-status</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #trackPrintStatus
--   </pre>
getPrintOperationTrackPrintStatus :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “<tt>track-print-status</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #trackPrintStatus <a>:=</a> value ]
--   </pre>
setPrintOperationTrackPrintStatus :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>track-print-status</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructPrintOperationTrackPrintStatus :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>unit</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #unit
--   </pre>
getPrintOperationUnit :: (MonadIO m, IsPrintOperation o) => o -> m Unit

-- | Set the value of the “<tt>unit</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #unit <a>:=</a> value ]
--   </pre>
setPrintOperationUnit :: (MonadIO m, IsPrintOperation o) => o -> Unit -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>unit</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPrintOperationUnit :: (IsPrintOperation o, MonadIO m) => Unit -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-full-page</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #useFullPage
--   </pre>
getPrintOperationUseFullPage :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “<tt>use-full-page</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #useFullPage <a>:=</a> value ]
--   </pre>
setPrintOperationUseFullPage :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-full-page</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPrintOperationUseFullPage :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>PrintOperation</a>.
--   
--   <i>Since: 2.10</i>
printOperationNew :: (HasCallStack, MonadIO m) => m PrintOperation

-- | Cancels a running print operation. This function may be called from a
--   <a>PrintOperation::beginPrint</a>, <a>PrintOperation::paginate</a> or
--   <a>PrintOperation::drawPage</a> signal handler to stop the currently
--   running print operation.
--   
--   <i>Since: 2.10</i>
printOperationCancel :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m ()

-- | Signalize that drawing of particular page is complete.
--   
--   It is called after completion of page drawing (e.g. drawing in another
--   thread). If <a>printOperationSetDeferDrawing</a> was called before,
--   then this function has to be called by application. In another case it
--   is called by the library itself.
--   
--   <i>Since: 2.16</i>
printOperationDrawPageFinish :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m ()

-- | Returns the default page setup, see
--   <a>printOperationSetDefaultPageSetup</a>.
--   
--   <i>Since: 2.10</i>
printOperationGetDefaultPageSetup :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m PageSetup

-- | Gets the value of <a>PrintOperation:embedPageSetup</a> property.
--   
--   <i>Since: 2.18</i>
printOperationGetEmbedPageSetup :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Bool

-- | Call this when the result of a print operation is
--   <a>PrintOperationResultError</a>, either as returned by
--   <a>printOperationRun</a>, or in the <a>PrintOperation::done</a> signal
--   handler. The returned <a>GError</a> will contain more details on what
--   went wrong.
--   
--   <i>Since: 2.10</i>
printOperationGetError :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m ()

-- | Gets the value of <a>PrintOperation:hasSelection</a> property.
--   
--   <i>Since: 2.18</i>
printOperationGetHasSelection :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Bool

-- | Returns the number of pages that will be printed.
--   
--   Note that this value is set during print preparation phase
--   (<a>PrintStatusPreparing</a>), so this function should never be called
--   before the data generation phase (<a>PrintStatusGeneratingData</a>).
--   You can connect to the <a>PrintOperation::statusChanged</a> signal and
--   call <a>printOperationGetNPagesToPrint</a> when print status is
--   <a>PrintStatusGeneratingData</a>. This is typically used to track the
--   progress of print operation.
--   
--   <i>Since: 2.18</i>
printOperationGetNPagesToPrint :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Int32

-- | Returns the current print settings.
--   
--   Note that the return value is <a>Nothing</a> until either
--   <a>printOperationSetPrintSettings</a> or <a>printOperationRun</a> have
--   been called.
--   
--   <i>Since: 2.10</i>
printOperationGetPrintSettings :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m PrintSettings

-- | Returns the status of the print operation. Also see
--   <a>printOperationGetStatusString</a>.
--   
--   <i>Since: 2.10</i>
printOperationGetStatus :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m PrintStatus

-- | Returns a string representation of the status of the print operation.
--   The string is translated and suitable for displaying the print status
--   e.g. in a <a>Statusbar</a>.
--   
--   Use <a>printOperationGetStatus</a> to obtain a status value that is
--   suitable for programmatic use.
--   
--   <i>Since: 2.10</i>
printOperationGetStatusString :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Text

-- | Gets the value of <a>PrintOperation:supportSelection</a> property.
--   
--   <i>Since: 2.18</i>
printOperationGetSupportSelection :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Bool

-- | A convenience function to find out if the print operation is finished,
--   either successfully (<a>PrintStatusFinished</a>) or unsuccessfully
--   (<a>PrintStatusFinishedAborted</a>).
--   
--   Note: when you enable print status tracking the print operation can be
--   in a non-finished state even after done has been called, as the
--   operation status then tracks the print job status on the printer.
--   
--   <i>Since: 2.10</i>
printOperationIsFinished :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Bool

-- | Sets whether the <a>printOperationRun</a> may return before the print
--   operation is completed. Note that some platforms may not allow
--   asynchronous operation.
--   
--   <i>Since: 2.10</i>
printOperationSetAllowAsync :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Sets the current page.
--   
--   If this is called before <a>printOperationRun</a>, the user will be
--   able to select to print only the current page.
--   
--   Note that this only makes sense for pre-paginated documents.
--   
--   <i>Since: 2.10</i>
printOperationSetCurrentPage :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Int32 -> m ()

-- | Sets the label for the tab holding custom widgets.
--   
--   <i>Since: 2.10</i>
printOperationSetCustomTabLabel :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Maybe Text -> m ()

-- | Makes <i><tt>defaultPageSetup</tt></i> the default page setup for
--   <i><tt>op</tt></i>.
--   
--   This page setup will be used by <a>printOperationRun</a>, but it can
--   be overridden on a per-page basis by connecting to the
--   <a>PrintOperation::requestPageSetup</a> signal.
--   
--   <i>Since: 2.10</i>
printOperationSetDefaultPageSetup :: (HasCallStack, MonadIO m, IsPrintOperation a, IsPageSetup b) => a -> Maybe b -> m ()

-- | Sets up the <a>PrintOperation</a> to wait for calling of
--   <a>printOperationDrawPageFinish</a> from application. It can be used
--   for drawing page in another thread.
--   
--   This function must be called in the callback of “draw-page” signal.
--   
--   <i>Since: 2.16</i>
printOperationSetDeferDrawing :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m ()

-- | Embed page size combo box and orientation combo box into page setup
--   page. Selected page setup is stored as default page setup in
--   <a>PrintOperation</a>.
--   
--   <i>Since: 2.18</i>
printOperationSetEmbedPageSetup :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Sets up the <a>PrintOperation</a> to generate a file instead of
--   showing the print dialog. The indended use of this function is for
--   implementing “Export to PDF” actions. Currently, PDF is the only
--   supported format.
--   
--   “Print to PDF” support is independent of this and is done by letting
--   the user pick the “Print to PDF” item from the list of printers in the
--   print dialog.
--   
--   <i>Since: 2.10</i>
printOperationSetExportFilename :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> [Char] -> m ()

-- | Sets whether there is a selection to print.
--   
--   Application has to set number of pages to which the selection will
--   draw by <a>printOperationSetNPages</a> in a callback of
--   <a>PrintOperation::beginPrint</a>.
--   
--   <i>Since: 2.18</i>
printOperationSetHasSelection :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Sets the name of the print job. The name is used to identify the job
--   (e.g. in monitoring applications like eggcups).
--   
--   If you don’t set a job name, GTK+ picks a default one by numbering
--   successive print jobs.
--   
--   <i>Since: 2.10</i>
printOperationSetJobName :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Text -> m ()

-- | Sets the number of pages in the document.
--   
--   This must be set to a positive number before the rendering starts. It
--   may be set in a <a>PrintOperation::beginPrint</a> signal hander.
--   
--   Note that the page numbers passed to the
--   <a>PrintOperation::requestPageSetup</a> and
--   <a>PrintOperation::drawPage</a> signals are 0-based, i.e. if the user
--   chooses to print all pages, the last <a>drawPage</a> signal will be
--   for page <i><tt>nPages</tt></i> - 1.
--   
--   <i>Since: 2.10</i>
printOperationSetNPages :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Int32 -> m ()

-- | Sets the print settings for <i><tt>op</tt></i>. This is typically used
--   to re-establish print settings from a previous print operation, see
--   <a>printOperationRun</a>.
--   
--   <i>Since: 2.10</i>
printOperationSetPrintSettings :: (HasCallStack, MonadIO m, IsPrintOperation a, IsPrintSettings b) => a -> Maybe b -> m ()

-- | If <i><tt>showProgress</tt></i> is <a>True</a>, the print operation
--   will show a progress dialog during the print operation.
--   
--   <i>Since: 2.10</i>
printOperationSetShowProgress :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Sets whether selection is supported by <a>PrintOperation</a>.
--   
--   <i>Since: 2.18</i>
printOperationSetSupportSelection :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | If track_status is <a>True</a>, the print operation will try to
--   continue report on the status of the print job in the printer queues
--   and printer. This can allow your application to show things like “out
--   of paper” issues, and when the print job actually reaches the printer.
--   
--   This function is often implemented using some form of polling, so it
--   should not be enabled unless needed.
--   
--   <i>Since: 2.10</i>
printOperationSetTrackPrintStatus :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Sets up the transformation for the cairo context obtained from
--   <a>PrintContext</a> in such a way that distances are measured in units
--   of <i><tt>unit</tt></i>.
--   
--   <i>Since: 2.10</i>
printOperationSetUnit :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Unit -> m ()

-- | If <i><tt>fullPage</tt></i> is <a>True</a>, the transformation for the
--   cairo context obtained from <a>PrintContext</a> puts the origin at the
--   top left corner of the page (which may not be the top left corner of
--   the sheet, depending on page orientation and the number of pages per
--   sheet). Otherwise, the origin is at the top left corner of the
--   imageable area (i.e. inside the margins).
--   
--   <i>Since: 2.10</i>
printOperationSetUseFullPage :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Cast to <a>Popover</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toPopover :: (MonadIO m, IsPopover o) => o -> m Popover

-- | Connect a signal handler for the <a>closed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> popover #closed callback
--   </pre>
onPopoverClosed :: (IsPopover a, MonadIO m) => a -> ((?self :: a) => PopoverClosedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>closed</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> popover #closed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPopoverClosed :: (IsPopover a, MonadIO m) => a -> ((?self :: a) => PopoverClosedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>constrain-to</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popover #constrainTo
--   </pre>
getPopoverConstrainTo :: (MonadIO m, IsPopover o) => o -> m PopoverConstraint

-- | Set the value of the “<tt>constrain-to</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popover [ #constrainTo <a>:=</a> value ]
--   </pre>
setPopoverConstrainTo :: (MonadIO m, IsPopover o) => o -> PopoverConstraint -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>constrain-to</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPopoverConstrainTo :: (IsPopover o, MonadIO m) => PopoverConstraint -> m (GValueConstruct o)

-- | Get the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popover #modal
--   </pre>
getPopoverModal :: (MonadIO m, IsPopover o) => o -> m Bool

-- | Set the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popover [ #modal <a>:=</a> value ]
--   </pre>
setPopoverModal :: (MonadIO m, IsPopover o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>modal</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPopoverModal :: (IsPopover o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>pointing-to</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popover #pointingTo
--   </pre>
getPopoverPointingTo :: (MonadIO m, IsPopover o) => o -> m (Maybe Rectangle)

-- | Set the value of the “<tt>pointing-to</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popover [ #pointingTo <a>:=</a> value ]
--   </pre>
setPopoverPointingTo :: (MonadIO m, IsPopover o) => o -> Rectangle -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pointing-to</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPopoverPointingTo :: (IsPopover o, MonadIO m) => Rectangle -> m (GValueConstruct o)

-- | Get the value of the “<tt>position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popover #position
--   </pre>
getPopoverPosition :: (MonadIO m, IsPopover o) => o -> m PositionType

-- | Set the value of the “<tt>position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popover [ #position <a>:=</a> value ]
--   </pre>
setPopoverPosition :: (MonadIO m, IsPopover o) => o -> PositionType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>position</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPopoverPosition :: (IsPopover o, MonadIO m) => PositionType -> m (GValueConstruct o)

-- | Get the value of the “<tt>relative-to</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popover #relativeTo
--   </pre>
getPopoverRelativeTo :: (MonadIO m, IsPopover o) => o -> m Widget

-- | Set the value of the “<tt>relative-to</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popover [ #relativeTo <a>:=</a> value ]
--   </pre>
setPopoverRelativeTo :: (MonadIO m, IsPopover o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>relative-to</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPopoverRelativeTo :: (IsPopover o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>relative-to</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #relativeTo
--   </pre>
clearPopoverRelativeTo :: (MonadIO m, IsPopover o) => o -> m ()

-- | Get the value of the “<tt>transitions-enabled</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popover #transitionsEnabled
--   </pre>
getPopoverTransitionsEnabled :: (MonadIO m, IsPopover o) => o -> m Bool

-- | Set the value of the “<tt>transitions-enabled</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popover [ #transitionsEnabled <a>:=</a> value ]
--   </pre>
setPopoverTransitionsEnabled :: (MonadIO m, IsPopover o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>transitions-enabled</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructPopoverTransitionsEnabled :: (IsPopover o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new popover to point to <i><tt>relativeTo</tt></i>
--   
--   <i>Since: 3.12</i>
popoverNew :: (HasCallStack, MonadIO m, IsWidget a) => Maybe a -> m Popover

-- | Establishes a binding between a <a>Popover</a> and a <a>MenuModel</a>.
--   
--   The contents of <i><tt>popover</tt></i> are removed and then refilled
--   with menu items according to <i><tt>model</tt></i>. When
--   <i><tt>model</tt></i> changes, <i><tt>popover</tt></i> is updated.
--   Calling this function twice on <i><tt>popover</tt></i> with different
--   <i><tt>model</tt></i> will cause the first binding to be replaced with
--   a binding to the new model. If <i><tt>model</tt></i> is <a>Nothing</a>
--   then any previous binding is undone and all children are removed.
--   
--   If <i><tt>actionNamespace</tt></i> is non-<a>Nothing</a> then the
--   effect is as if all actions mentioned in the <i><tt>model</tt></i>
--   have their names prefixed with the namespace, plus a dot. For example,
--   if the action “quit” is mentioned and <i><tt>actionNamespace</tt></i>
--   is “app” then the effective action name is “app.quit”.
--   
--   This function uses <a>Actionable</a> to define the action name and
--   target values on the created menu items. If you want to use an action
--   group other than “app” and “win”, or if you want to use a
--   <a>MenuShell</a> outside of a <a>ApplicationWindow</a>, then you will
--   need to attach your own action group to the widget hierarchy using
--   <a>widgetInsertActionGroup</a>. As an example, if you created a group
--   with a “quit” action and inserted it with the name “mygroup” then you
--   would use the action name “mygroup.quit” in your <a>MenuModel</a>.
--   
--   <i>Since: 3.12</i>
popoverBindModel :: (HasCallStack, MonadIO m, IsPopover a, IsMenuModel b) => a -> Maybe b -> Maybe Text -> m ()

-- | Returns the constraint for placing this popover. See
--   <a>popoverSetConstrainTo</a>.
--   
--   <i>Since: 3.20</i>
popoverGetConstrainTo :: (HasCallStack, MonadIO m, IsPopover a) => a -> m PopoverConstraint

-- | Gets the widget that should be set as the default while the popover is
--   shown.
--   
--   <i>Since: 3.18</i>
popoverGetDefaultWidget :: (HasCallStack, MonadIO m, IsPopover a) => a -> m (Maybe Widget)

-- | Returns whether the popover is modal, see gtk_popover_set_modal to see
--   the implications of this.
--   
--   <i>Since: 3.12</i>
popoverGetModal :: (HasCallStack, MonadIO m, IsPopover a) => a -> m Bool

-- | If a rectangle to point to has been set, this function will return
--   <a>True</a> and fill in <i><tt>rect</tt></i> with such rectangle,
--   otherwise it will return <a>False</a> and fill in <i><tt>rect</tt></i>
--   with the attached widget width and height if a widget exists,
--   otherwise it will zero-out <i><tt>rect</tt></i>.
popoverGetPointingTo :: (HasCallStack, MonadIO m, IsPopover a) => a -> m (Bool, Rectangle)

-- | Returns the preferred position of <i><tt>popover</tt></i>.
popoverGetPosition :: (HasCallStack, MonadIO m, IsPopover a) => a -> m PositionType

-- | Returns the widget <i><tt>popover</tt></i> is currently attached to
--   
--   <i>Since: 3.12</i>
popoverGetRelativeTo :: (HasCallStack, MonadIO m, IsPopover a) => a -> m Widget

-- | Returns whether show/hide transitions are enabled on this popover.
--   
--   <i>Since: 3.16</i>
popoverGetTransitionsEnabled :: (HasCallStack, MonadIO m, IsPopover a) => a -> m Bool

-- | Pops <i><tt>popover</tt></i> down.This is different than a
--   <a>widgetHide</a> call in that it shows the popover with a transition.
--   If you want to hide the popover without a transition, use
--   <a>widgetHide</a>.
--   
--   <i>Since: 3.22</i>
popoverPopdown :: (HasCallStack, MonadIO m, IsPopover a) => a -> m ()

-- | Pops <i><tt>popover</tt></i> up. This is different than a
--   <a>widgetShow</a> call in that it shows the popover with a transition.
--   If you want to show the popover without a transition, use
--   <a>widgetShow</a>.
--   
--   <i>Since: 3.22</i>
popoverPopup :: (HasCallStack, MonadIO m, IsPopover a) => a -> m ()

-- | Sets a constraint for positioning this popover.
--   
--   Note that not all platforms support placing popovers freely, and may
--   already impose constraints.
--   
--   <i>Since: 3.20</i>
popoverSetConstrainTo :: (HasCallStack, MonadIO m, IsPopover a) => a -> PopoverConstraint -> m ()

-- | Sets the widget that should be set as default widget while the popover
--   is shown (see <a>windowSetDefault</a>). <a>Popover</a> remembers the
--   previous default widget and reestablishes it when the popover is
--   dismissed.
--   
--   <i>Since: 3.18</i>
popoverSetDefaultWidget :: (HasCallStack, MonadIO m, IsPopover a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether <i><tt>popover</tt></i> is modal, a modal popover will
--   grab all input within the toplevel and grab the keyboard focus on it
--   when being displayed. Clicking outside the popover area or pressing
--   Esc will dismiss the popover and ungrab input.
--   
--   <i>Since: 3.12</i>
popoverSetModal :: (HasCallStack, MonadIO m, IsPopover a) => a -> Bool -> m ()

-- | Sets the rectangle that <i><tt>popover</tt></i> will point to, in the
--   coordinate space of the widget <i><tt>popover</tt></i> is attached to,
--   see <a>popoverSetRelativeTo</a>.
--   
--   <i>Since: 3.12</i>
popoverSetPointingTo :: (HasCallStack, MonadIO m, IsPopover a) => a -> Rectangle -> m ()

-- | Sets the preferred position for <i><tt>popover</tt></i> to appear. If
--   the <i><tt>popover</tt></i> is currently visible, it will be
--   immediately updated.
--   
--   This preference will be respected where possible, although on lack of
--   space (eg. if close to the window edges), the <a>Popover</a> may
--   choose to appear on the opposite side
--   
--   <i>Since: 3.12</i>
popoverSetPosition :: (HasCallStack, MonadIO m, IsPopover a) => a -> PositionType -> m ()

-- | Sets a new widget to be attached to <i><tt>popover</tt></i>. If
--   <i><tt>popover</tt></i> is visible, the position will be updated.
--   
--   Note: the ownership of popovers is always given to their
--   <i><tt>relativeTo</tt></i> widget, so if <i><tt>relativeTo</tt></i> is
--   set to <a>Nothing</a> on an attached <i><tt>popover</tt></i>, it will
--   be detached from its previous widget, and consequently destroyed
--   unless extra references are kept.
--   
--   <i>Since: 3.12</i>
popoverSetRelativeTo :: (HasCallStack, MonadIO m, IsPopover a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether show/hide transitions are enabled on this popover
--   
--   <i>Since: 3.16</i>
popoverSetTransitionsEnabled :: (HasCallStack, MonadIO m, IsPopover a) => a -> Bool -> m ()

-- | Cast to <a>PopoverMenu</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPopoverMenu :: (MonadIO m, IsPopoverMenu o) => o -> m PopoverMenu

-- | Get the value of the “<tt>visible-submenu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popoverMenu #visibleSubmenu
--   </pre>
getPopoverMenuVisibleSubmenu :: (MonadIO m, IsPopoverMenu o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>visible-submenu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popoverMenu [ #visibleSubmenu <a>:=</a> value ]
--   </pre>
setPopoverMenuVisibleSubmenu :: (MonadIO m, IsPopoverMenu o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible-submenu</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPopoverMenuVisibleSubmenu :: (IsPopoverMenu o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>visible-submenu</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #visibleSubmenu
--   </pre>
clearPopoverMenuVisibleSubmenu :: (MonadIO m, IsPopoverMenu o) => o -> m ()

-- | Creates a new popover menu.
--   
--   <i>Since: 3.16</i>
popoverMenuNew :: (HasCallStack, MonadIO m) => m PopoverMenu

-- | Opens a submenu of the <i><tt>popover</tt></i>. The
--   <i><tt>name</tt></i> must be one of the names given to the submenus of
--   <i><tt>popover</tt></i> with
--   <a>PopoverMenu</a>:<tt><i>submenu</i></tt>, or "main" to switch back
--   to the main menu.
--   
--   <a>ModelButton</a> will open submenus automatically when the
--   <a>ModelButton:menuName</a> property is set, so this function is only
--   needed when you are using other kinds of widgets to initiate menu
--   changes.
--   
--   <i>Since: 3.16</i>
popoverMenuOpenSubmenu :: (HasCallStack, MonadIO m, IsPopoverMenu a) => a -> Text -> m ()

-- | Cast to <a>Plug</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toPlug :: (MonadIO m, IsPlug o) => o -> m Plug

-- | Connect a signal handler for the <a>embedded</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> plug #embedded callback
--   </pre>
onPlugEmbedded :: (IsPlug a, MonadIO m) => a -> ((?self :: a) => PlugEmbeddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>embedded</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> plug #embedded callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPlugEmbedded :: (IsPlug a, MonadIO m) => a -> ((?self :: a) => PlugEmbeddedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>embedded</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> plug #embedded
--   </pre>
getPlugEmbedded :: (MonadIO m, IsPlug o) => o -> m Bool

-- | Get the value of the “<tt>socket-window</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> plug #socketWindow
--   </pre>
getPlugSocketWindow :: (MonadIO m, IsPlug o) => o -> m (Maybe Window)

-- | Create a new plug widget inside the <a>Socket</a> identified by
--   socket_id.
--   
--   <i>Since: 2.2</i>
plugNewForDisplay :: (HasCallStack, MonadIO m, IsDisplay a) => a -> CULong -> m Plug

-- | Finish the initialization of <i><tt>plug</tt></i> for a given
--   <a>Socket</a> identified by <i><tt>socketId</tt></i>. This function
--   will generally only be used by classes deriving from <a>Plug</a>.
plugConstruct :: (HasCallStack, MonadIO m, IsPlug a) => a -> CULong -> m ()

-- | Finish the initialization of <i><tt>plug</tt></i> for a given
--   <a>Socket</a> identified by <i><tt>socketId</tt></i> which is
--   currently displayed on <i><tt>display</tt></i>. This function will
--   generally only be used by classes deriving from <a>Plug</a>.
--   
--   <i>Since: 2.2</i>
plugConstructForDisplay :: (HasCallStack, MonadIO m, IsPlug a, IsDisplay b) => a -> b -> CULong -> m ()

-- | Determines whether the plug is embedded in a socket.
--   
--   <i>Since: 2.14</i>
plugGetEmbedded :: (HasCallStack, MonadIO m, IsPlug a) => a -> m Bool

-- | Retrieves the socket the plug is embedded in.
--   
--   <i>Since: 2.14</i>
plugGetSocketWindow :: (HasCallStack, MonadIO m, IsPlug a) => a -> m (Maybe Window)

-- | Cast to <a>PlacesSidebar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPlacesSidebar :: (MonadIO m, IsPlacesSidebar o) => o -> m PlacesSidebar

-- | Connect a signal handler for the <a>dragActionAsk</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> placesSidebar #dragActionAsk callback
--   </pre>
onPlacesSidebarDragActionAsk :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarDragActionAskCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragActionAsk</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> placesSidebar #dragActionAsk callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPlacesSidebarDragActionAsk :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarDragActionAskCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragActionRequested</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> placesSidebar #dragActionRequested callback
--   </pre>
onPlacesSidebarDragActionRequested :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarDragActionRequestedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragActionRequested</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> placesSidebar #dragActionRequested callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPlacesSidebarDragActionRequested :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarDragActionRequestedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragPerformDrop</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> placesSidebar #dragPerformDrop callback
--   </pre>
onPlacesSidebarDragPerformDrop :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarDragPerformDropCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragPerformDrop</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> placesSidebar #dragPerformDrop callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPlacesSidebarDragPerformDrop :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarDragPerformDropCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>mount</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> placesSidebar #mount callback
--   </pre>
onPlacesSidebarMount :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarMountCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>mount</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> placesSidebar #mount callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPlacesSidebarMount :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarMountCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>openLocation</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> placesSidebar #openLocation callback
--   </pre>
onPlacesSidebarOpenLocation :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarOpenLocationCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>openLocation</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> placesSidebar #openLocation callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPlacesSidebarOpenLocation :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarOpenLocationCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>populatePopup</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> placesSidebar #populatePopup callback
--   </pre>
onPlacesSidebarPopulatePopup :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarPopulatePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>populatePopup</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> placesSidebar #populatePopup callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPlacesSidebarPopulatePopup :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarPopulatePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showConnectToServer</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> placesSidebar #showConnectToServer callback
--   </pre>
onPlacesSidebarShowConnectToServer :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowConnectToServerCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showConnectToServer</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> placesSidebar #showConnectToServer callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPlacesSidebarShowConnectToServer :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowConnectToServerCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showEnterLocation</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> placesSidebar #showEnterLocation callback
--   </pre>
onPlacesSidebarShowEnterLocation :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowEnterLocationCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showEnterLocation</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> placesSidebar #showEnterLocation callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPlacesSidebarShowEnterLocation :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowEnterLocationCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showErrorMessage</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> placesSidebar #showErrorMessage callback
--   </pre>
onPlacesSidebarShowErrorMessage :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowErrorMessageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showErrorMessage</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> placesSidebar #showErrorMessage callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPlacesSidebarShowErrorMessage :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowErrorMessageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showOtherLocations</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> placesSidebar #showOtherLocations callback
--   </pre>
onPlacesSidebarShowOtherLocations :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowOtherLocationsCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showOtherLocations</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> placesSidebar #showOtherLocations callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPlacesSidebarShowOtherLocations :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowOtherLocationsCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showOtherLocationsWithFlags</a>
--   signal, to be run before the default handler. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> placesSidebar #showOtherLocationsWithFlags callback
--   </pre>
onPlacesSidebarShowOtherLocationsWithFlags :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowOtherLocationsWithFlagsCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showOtherLocationsWithFlags</a>
--   signal, to be run after the default handler. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> placesSidebar #showOtherLocationsWithFlags callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPlacesSidebarShowOtherLocationsWithFlags :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowOtherLocationsWithFlagsCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showStarredLocation</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> placesSidebar #showStarredLocation callback
--   </pre>
onPlacesSidebarShowStarredLocation :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowStarredLocationCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showStarredLocation</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> placesSidebar #showStarredLocation callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPlacesSidebarShowStarredLocation :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarShowStarredLocationCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unmount</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> placesSidebar #unmount callback
--   </pre>
onPlacesSidebarUnmount :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarUnmountCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unmount</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> placesSidebar #unmount callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPlacesSidebarUnmount :: (IsPlacesSidebar a, MonadIO m) => a -> ((?self :: a) => PlacesSidebarUnmountCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>local-only</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> placesSidebar #localOnly
--   </pre>
getPlacesSidebarLocalOnly :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “<tt>local-only</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> placesSidebar [ #localOnly <a>:=</a> value ]
--   </pre>
setPlacesSidebarLocalOnly :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>local-only</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPlacesSidebarLocalOnly :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>location</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> placesSidebar #location
--   </pre>
getPlacesSidebarLocation :: (MonadIO m, IsPlacesSidebar o) => o -> m (Maybe File)

-- | Set the value of the “<tt>location</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> placesSidebar [ #location <a>:=</a> value ]
--   </pre>
setPlacesSidebarLocation :: (MonadIO m, IsPlacesSidebar o, IsFile a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>location</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPlacesSidebarLocation :: (IsPlacesSidebar o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>location</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #location
--   </pre>
clearPlacesSidebarLocation :: (MonadIO m, IsPlacesSidebar o) => o -> m ()

-- | Get the value of the “<tt>open-flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> placesSidebar #openFlags
--   </pre>
getPlacesSidebarOpenFlags :: (MonadIO m, IsPlacesSidebar o) => o -> m [PlacesOpenFlags]

-- | Set the value of the “<tt>open-flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> placesSidebar [ #openFlags <a>:=</a> value ]
--   </pre>
setPlacesSidebarOpenFlags :: (MonadIO m, IsPlacesSidebar o) => o -> [PlacesOpenFlags] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>open-flags</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPlacesSidebarOpenFlags :: (IsPlacesSidebar o, MonadIO m) => [PlacesOpenFlags] -> m (GValueConstruct o)

-- | Get the value of the “<tt>populate-all</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> placesSidebar #populateAll
--   </pre>
getPlacesSidebarPopulateAll :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “<tt>populate-all</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> placesSidebar [ #populateAll <a>:=</a> value ]
--   </pre>
setPlacesSidebarPopulateAll :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>populate-all</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPlacesSidebarPopulateAll :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-connect-to-server</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> placesSidebar #showConnectToServer
--   </pre>
getPlacesSidebarShowConnectToServer :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “<tt>show-connect-to-server</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> placesSidebar [ #showConnectToServer <a>:=</a> value ]
--   </pre>
setPlacesSidebarShowConnectToServer :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-connect-to-server</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructPlacesSidebarShowConnectToServer :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-desktop</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> placesSidebar #showDesktop
--   </pre>
getPlacesSidebarShowDesktop :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “<tt>show-desktop</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> placesSidebar [ #showDesktop <a>:=</a> value ]
--   </pre>
setPlacesSidebarShowDesktop :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-desktop</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPlacesSidebarShowDesktop :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-enter-location</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> placesSidebar #showEnterLocation
--   </pre>
getPlacesSidebarShowEnterLocation :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “<tt>show-enter-location</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> placesSidebar [ #showEnterLocation <a>:=</a> value ]
--   </pre>
setPlacesSidebarShowEnterLocation :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-enter-location</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructPlacesSidebarShowEnterLocation :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-other-locations</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> placesSidebar #showOtherLocations
--   </pre>
getPlacesSidebarShowOtherLocations :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “<tt>show-other-locations</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> placesSidebar [ #showOtherLocations <a>:=</a> value ]
--   </pre>
setPlacesSidebarShowOtherLocations :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-other-locations</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructPlacesSidebarShowOtherLocations :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-recent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> placesSidebar #showRecent
--   </pre>
getPlacesSidebarShowRecent :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “<tt>show-recent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> placesSidebar [ #showRecent <a>:=</a> value ]
--   </pre>
setPlacesSidebarShowRecent :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-recent</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPlacesSidebarShowRecent :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-starred-location</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> placesSidebar #showStarredLocation
--   </pre>
getPlacesSidebarShowStarredLocation :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “<tt>show-starred-location</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> placesSidebar [ #showStarredLocation <a>:=</a> value ]
--   </pre>
setPlacesSidebarShowStarredLocation :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-starred-location</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructPlacesSidebarShowStarredLocation :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-trash</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> placesSidebar #showTrash
--   </pre>
getPlacesSidebarShowTrash :: (MonadIO m, IsPlacesSidebar o) => o -> m Bool

-- | Set the value of the “<tt>show-trash</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> placesSidebar [ #showTrash <a>:=</a> value ]
--   </pre>
setPlacesSidebarShowTrash :: (MonadIO m, IsPlacesSidebar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-trash</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPlacesSidebarShowTrash :: (IsPlacesSidebar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>PlacesSidebar</a> widget.
--   
--   The application should connect to at least the
--   <a>PlacesSidebar::openLocation</a> signal to be notified when the user
--   makes a selection in the sidebar.
--   
--   <i>Since: 3.10</i>
placesSidebarNew :: (HasCallStack, MonadIO m) => m PlacesSidebar

-- | Applications may want to present some folders in the places sidebar if
--   they could be immediately useful to users. For example, a drawing
--   program could add a “/usr/share/clipart” location when the sidebar is
--   being used in an “Insert Clipart” dialog box.
--   
--   This function adds the specified <i><tt>location</tt></i> to a special
--   place for immutable shortcuts. The shortcuts are application-specific;
--   they are not shared across applications, and they are not persistent.
--   If this function is called multiple times with different locations,
--   then they are added to the sidebar’s list in the same order as the
--   function is called.
--   
--   <i>Since: 3.10</i>
placesSidebarAddShortcut :: (HasCallStack, MonadIO m, IsPlacesSidebar a, IsFile b) => a -> b -> m ()

-- | Returns the value previously set with
--   <a>placesSidebarSetLocalOnly</a>.
--   
--   <i>Since: 3.12</i>
placesSidebarGetLocalOnly :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m Bool

-- | Gets the currently selected location in the <i><tt>sidebar</tt></i>.
--   This can be <a>Nothing</a> when nothing is selected, for example, when
--   <a>placesSidebarSetLocation</a> has been called with a location that
--   is not among the sidebar’s list of places to show.
--   
--   You can use this function to get the selection in the
--   <i><tt>sidebar</tt></i>. Also, if you connect to the
--   <a>PlacesSidebar::populatePopup</a> signal, you can use this function
--   to get the location that is being referred to during the callbacks for
--   your menu items.
--   
--   <i>Since: 3.10</i>
placesSidebarGetLocation :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m (Maybe File)

-- | This function queries the bookmarks added by the user to the places
--   sidebar, and returns one of them. This function is used by
--   <a>FileChooser</a> to implement the “Alt-1”, “Alt-2”, etc. shortcuts,
--   which activate the cooresponding bookmark.
--   
--   <i>Since: 3.10</i>
placesSidebarGetNthBookmark :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Int32 -> m (Maybe File)

-- | Gets the open flags.
--   
--   <i>Since: 3.10</i>
placesSidebarGetOpenFlags :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m [PlacesOpenFlags]

-- | Returns the value previously set with
--   <a>placesSidebarSetShowConnectToServer</a>
placesSidebarGetShowConnectToServer :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m Bool

-- | Returns the value previously set with
--   <a>placesSidebarSetShowDesktop</a>
--   
--   <i>Since: 3.10</i>
placesSidebarGetShowDesktop :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m Bool

-- | Returns the value previously set with
--   <a>placesSidebarSetShowEnterLocation</a>
--   
--   <i>Since: 3.14</i>
placesSidebarGetShowEnterLocation :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m Bool

-- | Returns the value previously set with
--   <a>placesSidebarSetShowOtherLocations</a>
--   
--   <i>Since: 3.18</i>
placesSidebarGetShowOtherLocations :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m Bool

-- | Returns the value previously set with
--   <a>placesSidebarSetShowRecent</a>
--   
--   <i>Since: 3.18</i>
placesSidebarGetShowRecent :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m Bool

-- | Returns the value previously set with
--   <a>placesSidebarSetShowStarredLocation</a>
--   
--   <i>Since: 3.22.26</i>
placesSidebarGetShowStarredLocation :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m Bool

-- | Returns the value previously set with <a>placesSidebarSetShowTrash</a>
--   
--   <i>Since: 3.18</i>
placesSidebarGetShowTrash :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m Bool

-- | Gets the list of shortcuts.
--   
--   <i>Since: 3.10</i>
placesSidebarListShortcuts :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> m [File]

-- | Removes an application-specific shortcut that has been previously been
--   inserted with <a>placesSidebarAddShortcut</a>. If the
--   <i><tt>location</tt></i> is not a shortcut in the sidebar, then
--   nothing is done.
--   
--   <i>Since: 3.10</i>
placesSidebarRemoveShortcut :: (HasCallStack, MonadIO m, IsPlacesSidebar a, IsFile b) => a -> b -> m ()

-- | Make the GtkPlacesSidebar show drop targets, so it can show the
--   available drop targets and a "new bookmark" row. This improves the
--   Drag-and-Drop experience of the user and allows applications to show
--   all available drop targets at once.
--   
--   This needs to be called when the application is aware of an ongoing
--   drag that might target the sidebar. The drop-targets-visible state
--   will be unset automatically if the drag finishes in the
--   GtkPlacesSidebar. You only need to unset the state when the drag ends
--   on some other widget on your application.
--   
--   <i>Since: 3.18</i>
placesSidebarSetDropTargetsVisible :: (HasCallStack, MonadIO m, IsPlacesSidebar a, IsDragContext b) => a -> Bool -> b -> m ()

-- | Sets whether the <i><tt>sidebar</tt></i> should only show local files.
--   
--   <i>Since: 3.12</i>
placesSidebarSetLocalOnly :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Bool -> m ()

-- | Sets the location that is being shown in the widgets surrounding the
--   <i><tt>sidebar</tt></i>, for example, in a folder view in a file
--   manager. In turn, the <i><tt>sidebar</tt></i> will highlight that
--   location if it is being shown in the list of places, or it will
--   unhighlight everything if the <i><tt>location</tt></i> is not among
--   the places in the list.
--   
--   <i>Since: 3.10</i>
placesSidebarSetLocation :: (HasCallStack, MonadIO m, IsPlacesSidebar a, IsFile b) => a -> Maybe b -> m ()

-- | Sets whether the <i><tt>sidebar</tt></i> should show an item for
--   connecting to a network server; this is off by default. An application
--   may want to turn this on if it implements a way for the user to
--   connect to network servers directly.
--   
--   If you enable this, you should connect to the
--   <a>PlacesSidebar::showConnectToServer</a> signal.
--   
--   <i>Since: 3.10</i>
placesSidebarSetShowConnectToServer :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Bool -> m ()

-- | Sets whether the <i><tt>sidebar</tt></i> should show an item for the
--   Desktop folder. The default value for this option is determined by the
--   desktop environment and the user’s configuration, but this function
--   can be used to override it on a per-application basis.
--   
--   <i>Since: 3.10</i>
placesSidebarSetShowDesktop :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Bool -> m ()

-- | Sets whether the <i><tt>sidebar</tt></i> should show an item for
--   entering a location; this is off by default. An application may want
--   to turn this on if manually entering URLs is an expected user action.
--   
--   If you enable this, you should connect to the
--   <a>PlacesSidebar::showEnterLocation</a> signal.
--   
--   <i>Since: 3.14</i>
placesSidebarSetShowEnterLocation :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Bool -> m ()

-- | Sets whether the <i><tt>sidebar</tt></i> should show an item for the
--   application to show an Other Locations view; this is off by default.
--   When set to <a>True</a>, persistent devices such as hard drives are
--   hidden, otherwise they are shown in the sidebar. An application may
--   want to turn this on if it implements a way for the user to see and
--   interact with drives and network servers directly.
--   
--   If you enable this, you should connect to the
--   <a>PlacesSidebar::showOtherLocations</a> signal.
--   
--   <i>Since: 3.18</i>
placesSidebarSetShowOtherLocations :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Bool -> m ()

-- | Sets whether the <i><tt>sidebar</tt></i> should show an item for
--   recent files. The default value for this option is determined by the
--   desktop environment, but this function can be used to override it on a
--   per-application basis.
--   
--   <i>Since: 3.18</i>
placesSidebarSetShowRecent :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Bool -> m ()

-- | If you enable this, you should connect to the
--   <a>PlacesSidebar::showStarredLocation</a> signal.
--   
--   <i>Since: 3.22.26</i>
placesSidebarSetShowStarredLocation :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Bool -> m ()

-- | Sets whether the <i><tt>sidebar</tt></i> should show an item for the
--   Trash location.
--   
--   <i>Since: 3.18</i>
placesSidebarSetShowTrash :: (HasCallStack, MonadIO m, IsPlacesSidebar a) => a -> Bool -> m ()

-- | Cast to <a>Paned</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toPaned :: (MonadIO m, IsPaned o) => o -> m Paned

-- | Connect a signal handler for the <a>acceptPosition</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> paned #acceptPosition callback
--   </pre>
onPanedAcceptPosition :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedAcceptPositionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>acceptPosition</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> paned #acceptPosition callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPanedAcceptPosition :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedAcceptPositionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cancelPosition</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> paned #cancelPosition callback
--   </pre>
onPanedCancelPosition :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCancelPositionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cancelPosition</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> paned #cancelPosition callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPanedCancelPosition :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCancelPositionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cycleChildFocus</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> paned #cycleChildFocus callback
--   </pre>
onPanedCycleChildFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCycleChildFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cycleChildFocus</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> paned #cycleChildFocus callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPanedCycleChildFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCycleChildFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cycleHandleFocus</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> paned #cycleHandleFocus callback
--   </pre>
onPanedCycleHandleFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCycleHandleFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cycleHandleFocus</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> paned #cycleHandleFocus callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPanedCycleHandleFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCycleHandleFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveHandle</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> paned #moveHandle callback
--   </pre>
onPanedMoveHandle :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedMoveHandleCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveHandle</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> paned #moveHandle callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPanedMoveHandle :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedMoveHandleCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleHandleFocus</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> paned #toggleHandleFocus callback
--   </pre>
onPanedToggleHandleFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedToggleHandleFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleHandleFocus</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> paned #toggleHandleFocus callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPanedToggleHandleFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedToggleHandleFocusCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>max-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paned #maxPosition
--   </pre>
getPanedMaxPosition :: (MonadIO m, IsPaned o) => o -> m Int32

-- | Get the value of the “<tt>min-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paned #minPosition
--   </pre>
getPanedMinPosition :: (MonadIO m, IsPaned o) => o -> m Int32

-- | Get the value of the “<tt>position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paned #position
--   </pre>
getPanedPosition :: (MonadIO m, IsPaned o) => o -> m Int32

-- | Set the value of the “<tt>position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paned [ #position <a>:=</a> value ]
--   </pre>
setPanedPosition :: (MonadIO m, IsPaned o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>position</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPanedPosition :: (IsPaned o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>position-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paned #positionSet
--   </pre>
getPanedPositionSet :: (MonadIO m, IsPaned o) => o -> m Bool

-- | Set the value of the “<tt>position-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paned [ #positionSet <a>:=</a> value ]
--   </pre>
setPanedPositionSet :: (MonadIO m, IsPaned o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>position-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPanedPositionSet :: (IsPaned o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>wide-handle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paned #wideHandle
--   </pre>
getPanedWideHandle :: (MonadIO m, IsPaned o) => o -> m Bool

-- | Set the value of the “<tt>wide-handle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paned [ #wideHandle <a>:=</a> value ]
--   </pre>
setPanedWideHandle :: (MonadIO m, IsPaned o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wide-handle</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPanedWideHandle :: (IsPaned o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>Paned</a> widget.
--   
--   <i>Since: 3.0</i>
panedNew :: (HasCallStack, MonadIO m) => Orientation -> m Paned

-- | Adds a child to the top or left pane with default parameters. This is
--   equivalent to <tt>gtk_paned_pack1 (paned, child, FALSE, TRUE)</tt>.
panedAdd1 :: (HasCallStack, MonadIO m, IsPaned a, IsWidget b) => a -> b -> m ()

-- | Adds a child to the bottom or right pane with default parameters. This
--   is equivalent to <tt>gtk_paned_pack2 (paned, child, TRUE, TRUE)</tt>.
panedAdd2 :: (HasCallStack, MonadIO m, IsPaned a, IsWidget b) => a -> b -> m ()

-- | Obtains the first child of the paned widget.
--   
--   <i>Since: 2.4</i>
panedGetChild1 :: (HasCallStack, MonadIO m, IsPaned a) => a -> m (Maybe Widget)

-- | Obtains the second child of the paned widget.
--   
--   <i>Since: 2.4</i>
panedGetChild2 :: (HasCallStack, MonadIO m, IsPaned a) => a -> m (Maybe Widget)

-- | Returns the <a>Window</a> of the handle. This function is useful when
--   handling button or motion events because it enables the callback to
--   distinguish between the window of the paned, a child and the handle.
--   
--   <i>Since: 2.20</i>
panedGetHandleWindow :: (HasCallStack, MonadIO m, IsPaned a) => a -> m Window

-- | Obtains the position of the divider between the two panes.
panedGetPosition :: (HasCallStack, MonadIO m, IsPaned a) => a -> m Int32

-- | Gets the <a>Paned:wideHandle</a> property.
--   
--   <i>Since: 3.16</i>
panedGetWideHandle :: (HasCallStack, MonadIO m, IsPaned a) => a -> m Bool

-- | Adds a child to the top or left pane.
panedPack1 :: (HasCallStack, MonadIO m, IsPaned a, IsWidget b) => a -> b -> Bool -> Bool -> m ()

-- | Adds a child to the bottom or right pane.
panedPack2 :: (HasCallStack, MonadIO m, IsPaned a, IsWidget b) => a -> b -> Bool -> Bool -> m ()

-- | Sets the position of the divider between the two panes.
panedSetPosition :: (HasCallStack, MonadIO m, IsPaned a) => a -> Int32 -> m ()

-- | Sets the <a>Paned:wideHandle</a> property.
--   
--   <i>Since: 3.16</i>
panedSetWideHandle :: (HasCallStack, MonadIO m, IsPaned a) => a -> Bool -> m ()

-- | Cast to <a>VPaned</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toVPaned :: (MonadIO m, IsVPaned o) => o -> m VPaned

-- | Create a new <a>VPaned</a>
vPanedNew :: (HasCallStack, MonadIO m) => m VPaned

-- | Cast to <a>Overlay</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toOverlay :: (MonadIO m, IsOverlay o) => o -> m Overlay

-- | Connect a signal handler for the <a>getChildPosition</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> overlay #getChildPosition callback
--   </pre>
onOverlayGetChildPosition :: (IsOverlay a, MonadIO m) => a -> ((?self :: a) => OverlayGetChildPositionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>getChildPosition</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> overlay #getChildPosition callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterOverlayGetChildPosition :: (IsOverlay a, MonadIO m) => a -> ((?self :: a) => OverlayGetChildPositionCallback) -> m SignalHandlerId

-- | Creates a new <a>Overlay</a>.
--   
--   <i>Since: 3.2</i>
overlayNew :: (HasCallStack, MonadIO m) => m Overlay

-- | Adds <i><tt>widget</tt></i> to <i><tt>overlay</tt></i>.
--   
--   The widget will be stacked on top of the main widget added with
--   <a>containerAdd</a>.
--   
--   The position at which <i><tt>widget</tt></i> is placed is determined
--   from its <a>Widget:halign</a> and <a>Widget:valign</a> properties.
--   
--   <i>Since: 3.2</i>
overlayAddOverlay :: (HasCallStack, MonadIO m, IsOverlay a, IsWidget b) => a -> b -> m ()

-- | Convenience function to get the value of the
--   <a>Overlay</a>:<tt><i>pass-through</i></tt> child property for
--   <i><tt>widget</tt></i>.
--   
--   <i>Since: 3.18</i>
overlayGetOverlayPassThrough :: (HasCallStack, MonadIO m, IsOverlay a, IsWidget b) => a -> b -> m Bool

-- | Moves <i><tt>child</tt></i> to a new <i><tt>index</tt></i> in the list
--   of <i><tt>overlay</tt></i> children. The list contains overlays in the
--   order that these were added to <i><tt>overlay</tt></i> by default. See
--   also <a>Overlay</a>:<tt><i>index</i></tt>.
--   
--   A widget’s index in the <i><tt>overlay</tt></i> children list
--   determines which order the children are drawn if they overlap. The
--   first child is drawn at the bottom. It also affects the default focus
--   chain order.
--   
--   <i>Since: 3.18</i>
overlayReorderOverlay :: (HasCallStack, MonadIO m, IsOverlay a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Convenience function to set the value of the
--   <a>Overlay</a>:<tt><i>pass-through</i></tt> child property for
--   <i><tt>widget</tt></i>.
--   
--   <i>Since: 3.18</i>
overlaySetOverlayPassThrough :: (HasCallStack, MonadIO m, IsOverlay a, IsWidget b) => a -> b -> Bool -> m ()

-- | Cast to <a>OffscreenWindow</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toOffscreenWindow :: (MonadIO m, IsOffscreenWindow o) => o -> m OffscreenWindow

-- | Creates a toplevel container widget that is used to retrieve snapshots
--   of widgets without showing them on the screen.
--   
--   <i>Since: 2.20</i>
offscreenWindowNew :: (HasCallStack, MonadIO m) => m OffscreenWindow

-- | Retrieves a snapshot of the contained widget in the form of a
--   <a>Pixbuf</a>. This is a new pixbuf with a reference count of 1, and
--   the application should unreference it once it is no longer needed.
--   
--   <i>Since: 2.20</i>
offscreenWindowGetPixbuf :: (HasCallStack, MonadIO m, IsOffscreenWindow a) => a -> m (Maybe Pixbuf)

-- | Cast to <a>NumerableIcon</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toNumerableIcon :: (MonadIO m, IsNumerableIcon o) => o -> m NumerableIcon

-- | Get the value of the “<tt>background-icon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> numerableIcon #backgroundIcon
--   </pre>
getNumerableIconBackgroundIcon :: (MonadIO m, IsNumerableIcon o) => o -> m (Maybe Icon)

-- | Set the value of the “<tt>background-icon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> numerableIcon [ #backgroundIcon <a>:=</a> value ]
--   </pre>
setNumerableIconBackgroundIcon :: (MonadIO m, IsNumerableIcon o, IsIcon a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-icon</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructNumerableIconBackgroundIcon :: (IsNumerableIcon o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>background-icon</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #backgroundIcon
--   </pre>
clearNumerableIconBackgroundIcon :: (MonadIO m, IsNumerableIcon o) => o -> m ()

-- | Get the value of the “<tt>background-icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> numerableIcon #backgroundIconName
--   </pre>
getNumerableIconBackgroundIconName :: (MonadIO m, IsNumerableIcon o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>background-icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> numerableIcon [ #backgroundIconName <a>:=</a> value ]
--   </pre>
setNumerableIconBackgroundIconName :: (MonadIO m, IsNumerableIcon o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-icon-name</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructNumerableIconBackgroundIconName :: (IsNumerableIcon o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>background-icon-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #backgroundIconName
--   </pre>
clearNumerableIconBackgroundIconName :: (MonadIO m, IsNumerableIcon o) => o -> m ()

-- | Get the value of the “<tt>count</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> numerableIcon #count
--   </pre>
getNumerableIconCount :: (MonadIO m, IsNumerableIcon o) => o -> m Int32

-- | Set the value of the “<tt>count</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> numerableIcon [ #count <a>:=</a> value ]
--   </pre>
setNumerableIconCount :: (MonadIO m, IsNumerableIcon o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>count</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNumerableIconCount :: (IsNumerableIcon o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> numerableIcon #label
--   </pre>
getNumerableIconLabel :: (MonadIO m, IsNumerableIcon o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> numerableIcon [ #label <a>:=</a> value ]
--   </pre>
setNumerableIconLabel :: (MonadIO m, IsNumerableIcon o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNumerableIconLabel :: (IsNumerableIcon o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>label</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #label
--   </pre>
clearNumerableIconLabel :: (MonadIO m, IsNumerableIcon o) => o -> m ()

-- | Get the value of the “<tt>style-context</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> numerableIcon #styleContext
--   </pre>
getNumerableIconStyleContext :: (MonadIO m, IsNumerableIcon o) => o -> m (Maybe StyleContext)

-- | Set the value of the “<tt>style-context</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> numerableIcon [ #styleContext <a>:=</a> value ]
--   </pre>
setNumerableIconStyleContext :: (MonadIO m, IsNumerableIcon o, IsStyleContext a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>style-context</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructNumerableIconStyleContext :: (IsNumerableIcon o, MonadIO m, IsStyleContext a) => a -> m (GValueConstruct o)

-- | Returns the <a>Icon</a> that was set as the base background image, or
--   <a>Nothing</a> if there’s none. The caller of this function does not
--   own a reference to the returned <a>Icon</a>.
--   
--   <i>Since: 3.0</i>
numerableIconGetBackgroundGicon :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> m (Maybe Icon)

-- | Returns the icon name used as the base background image, or
--   <a>Nothing</a> if there’s none.
--   
--   <i>Since: 3.0</i>
numerableIconGetBackgroundIconName :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> m (Maybe Text)

-- | Returns the value currently displayed by <i><tt>self</tt></i>.
--   
--   <i>Since: 3.0</i>
numerableIconGetCount :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> m Int32

-- | Returns the currently displayed label of the icon, or <a>Nothing</a>.
--   
--   <i>Since: 3.0</i>
numerableIconGetLabel :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> m (Maybe Text)

-- | Returns the <a>StyleContext</a> used by the icon for theming, or
--   <a>Nothing</a> if there’s none.
--   
--   <i>Since: 3.0</i>
numerableIconGetStyleContext :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> m (Maybe StyleContext)

-- | Updates the icon to use <i><tt>icon</tt></i> as the base background
--   image. If <i><tt>icon</tt></i> is <a>Nothing</a>, <i><tt>self</tt></i>
--   will go back using style information or default theming for its
--   background image.
--   
--   If this method is called and an icon name was already set as
--   background for the icon, <i><tt>icon</tt></i> will be used, i.e. the
--   last method called between <a>numerableIconSetBackgroundGicon</a> and
--   <a>numerableIconSetBackgroundIconName</a> has always priority.
--   
--   <i>Since: 3.0</i>
numerableIconSetBackgroundGicon :: (HasCallStack, MonadIO m, IsNumerableIcon a, IsIcon b) => a -> Maybe b -> m ()

-- | Updates the icon to use the icon named <i><tt>iconName</tt></i> from
--   the current icon theme as the base background image. If
--   <i><tt>iconName</tt></i> is <a>Nothing</a>, <i><tt>self</tt></i> will
--   go back using style information or default theming for its background
--   image.
--   
--   If this method is called and a <a>Icon</a> was already set as
--   background for the icon, <i><tt>iconName</tt></i> will be used, i.e.
--   the last method called between
--   <a>numerableIconSetBackgroundIconName</a> and
--   <a>numerableIconSetBackgroundGicon</a> has always priority.
--   
--   <i>Since: 3.0</i>
numerableIconSetBackgroundIconName :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> Maybe Text -> m ()

-- | Sets the currently displayed value of <i><tt>self</tt></i> to
--   <i><tt>count</tt></i>.
--   
--   The numeric value is always clamped to make it two digits, i.e.
--   between -99 and 99. Setting a count of zero removes the emblem. If
--   this method is called, and a label was already set on the icon, it
--   will automatically be reset to <a>Nothing</a> before rendering the
--   number, i.e. the last method called between
--   <a>numerableIconSetCount</a> and <a>numerableIconSetLabel</a> has
--   always priority.
--   
--   <i>Since: 3.0</i>
numerableIconSetCount :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> Int32 -> m ()

-- | Sets the currently displayed value of <i><tt>self</tt></i> to the
--   string in <i><tt>label</tt></i>. Setting an empty label removes the
--   emblem.
--   
--   Note that this is meant for displaying short labels, such as roman
--   numbers, or single letters. For roman numbers, consider using the
--   Unicode characters U+2160 - U+217F. Strings longer than two characters
--   will likely not be rendered very well.
--   
--   If this method is called, and a number was already set on the icon, it
--   will automatically be reset to zero before rendering the label, i.e.
--   the last method called between <a>numerableIconSetLabel</a> and
--   <a>numerableIconSetCount</a> has always priority.
--   
--   <i>Since: 3.0</i>
numerableIconSetLabel :: (HasCallStack, MonadIO m, IsNumerableIcon a) => a -> Maybe Text -> m ()

-- | Updates the icon to fetch theme information from the given
--   <a>StyleContext</a>.
--   
--   <i>Since: 3.0</i>
numerableIconSetStyleContext :: (HasCallStack, MonadIO m, IsNumerableIcon a, IsStyleContext b) => a -> b -> m ()

-- | Creates a new unthemed <a>NumerableIcon</a>.
--   
--   <i>Since: 3.0</i>
numerableIconNew :: (HasCallStack, MonadIO m, IsIcon a) => a -> m Icon

-- | Creates a new <a>NumerableIcon</a> which will themed according to the
--   passed <a>StyleContext</a>. This is a convenience constructor that
--   calls <a>numerableIconSetStyleContext</a> internally.
--   
--   <i>Since: 3.0</i>
numerableIconNewWithStyleContext :: (HasCallStack, MonadIO m, IsIcon a, IsStyleContext b) => a -> b -> m Icon

-- | Cast to <a>Notebook</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toNotebook :: (MonadIO m, IsNotebook o) => o -> m Notebook

-- | Connect a signal handler for the <a>changeCurrentPage</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #changeCurrentPage callback
--   </pre>
onNotebookChangeCurrentPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookChangeCurrentPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changeCurrentPage</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> notebook #changeCurrentPage callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookChangeCurrentPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookChangeCurrentPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>createWindow</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #createWindow callback
--   </pre>
onNotebookCreateWindow :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookCreateWindowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>createWindow</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> notebook #createWindow callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookCreateWindow :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookCreateWindowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>focusTab</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #focusTab callback
--   </pre>
onNotebookFocusTab :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookFocusTabCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>focusTab</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> notebook #focusTab callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookFocusTab :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookFocusTabCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveFocusOut</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #moveFocusOut callback
--   </pre>
onNotebookMoveFocusOut :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookMoveFocusOutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveFocusOut</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> notebook #moveFocusOut callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookMoveFocusOut :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookMoveFocusOutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pageAdded</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #pageAdded callback
--   </pre>
onNotebookPageAdded :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pageAdded</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> notebook #pageAdded callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookPageAdded :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pageRemoved</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #pageRemoved callback
--   </pre>
onNotebookPageRemoved :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageRemovedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pageRemoved</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> notebook #pageRemoved callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookPageRemoved :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageRemovedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pageReordered</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #pageReordered callback
--   </pre>
onNotebookPageReordered :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageReorderedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pageReordered</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> notebook #pageReordered callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookPageReordered :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageReorderedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>reorderTab</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #reorderTab callback
--   </pre>
onNotebookReorderTab :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookReorderTabCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>reorderTab</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> notebook #reorderTab callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookReorderTab :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookReorderTabCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectPage</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #selectPage callback
--   </pre>
onNotebookSelectPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookSelectPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectPage</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> notebook #selectPage callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookSelectPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookSelectPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>switchPage</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #switchPage callback
--   </pre>
onNotebookSwitchPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookSwitchPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>switchPage</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> notebook #switchPage callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookSwitchPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookSwitchPageCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>enable-popup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebook #enablePopup
--   </pre>
getNotebookEnablePopup :: (MonadIO m, IsNotebook o) => o -> m Bool

-- | Set the value of the “<tt>enable-popup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebook [ #enablePopup <a>:=</a> value ]
--   </pre>
setNotebookEnablePopup :: (MonadIO m, IsNotebook o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-popup</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructNotebookEnablePopup :: (IsNotebook o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>group-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebook #groupName
--   </pre>
getNotebookGroupName :: (MonadIO m, IsNotebook o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>group-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebook [ #groupName <a>:=</a> value ]
--   </pre>
setNotebookGroupName :: (MonadIO m, IsNotebook o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>group-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructNotebookGroupName :: (IsNotebook o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>group-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #groupName
--   </pre>
clearNotebookGroupName :: (MonadIO m, IsNotebook o) => o -> m ()

-- | Get the value of the “<tt>page</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebook #page
--   </pre>
getNotebookPage :: (MonadIO m, IsNotebook o) => o -> m Int32

-- | Set the value of the “<tt>page</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebook [ #page <a>:=</a> value ]
--   </pre>
setNotebookPage :: (MonadIO m, IsNotebook o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>page</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNotebookPage :: (IsNotebook o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>scrollable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebook #scrollable
--   </pre>
getNotebookScrollable :: (MonadIO m, IsNotebook o) => o -> m Bool

-- | Set the value of the “<tt>scrollable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebook [ #scrollable <a>:=</a> value ]
--   </pre>
setNotebookScrollable :: (MonadIO m, IsNotebook o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>scrollable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructNotebookScrollable :: (IsNotebook o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-border</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebook #showBorder
--   </pre>
getNotebookShowBorder :: (MonadIO m, IsNotebook o) => o -> m Bool

-- | Set the value of the “<tt>show-border</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebook [ #showBorder <a>:=</a> value ]
--   </pre>
setNotebookShowBorder :: (MonadIO m, IsNotebook o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-border</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructNotebookShowBorder :: (IsNotebook o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-tabs</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebook #showTabs
--   </pre>
getNotebookShowTabs :: (MonadIO m, IsNotebook o) => o -> m Bool

-- | Set the value of the “<tt>show-tabs</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebook [ #showTabs <a>:=</a> value ]
--   </pre>
setNotebookShowTabs :: (MonadIO m, IsNotebook o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-tabs</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructNotebookShowTabs :: (IsNotebook o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>tab-pos</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebook #tabPos
--   </pre>
getNotebookTabPos :: (MonadIO m, IsNotebook o) => o -> m PositionType

-- | Set the value of the “<tt>tab-pos</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebook [ #tabPos <a>:=</a> value ]
--   </pre>
setNotebookTabPos :: (MonadIO m, IsNotebook o) => o -> PositionType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tab-pos</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNotebookTabPos :: (IsNotebook o, MonadIO m) => PositionType -> m (GValueConstruct o)

-- | Creates a new <a>Notebook</a> widget with no pages.
notebookNew :: (HasCallStack, MonadIO m) => m Notebook

-- | Appends a page to <i><tt>notebook</tt></i>.
notebookAppendPage :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m Int32

-- | Appends a page to <i><tt>notebook</tt></i>, specifying the widget to
--   use as the label in the popup menu.
notebookAppendPageMenu :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c, IsWidget d) => a -> b -> Maybe c -> Maybe d -> m Int32

-- | Removes the child from the notebook.
--   
--   This function is very similar to <a>containerRemove</a>, but
--   additionally informs the notebook that the removal is happening as
--   part of a tab DND operation, which should not be cancelled.
--   
--   <i>Since: 3.16</i>
notebookDetachTab :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m ()

-- | Gets one of the action widgets. See <a>notebookSetActionWidget</a>.
--   
--   <i>Since: 2.20</i>
notebookGetActionWidget :: (HasCallStack, MonadIO m, IsNotebook a) => a -> PackType -> m (Maybe Widget)

-- | Returns the page number of the current page.
notebookGetCurrentPage :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Int32

-- | Gets the current group name for <i><tt>notebook</tt></i>.
--   
--   <i>Since: 2.24</i>
notebookGetGroupName :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m (Maybe Text)

-- | Retrieves the menu label widget of the page containing
--   <i><tt>child</tt></i>.
notebookGetMenuLabel :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m (Maybe Widget)

-- | Retrieves the text of the menu label for the page containing
--   <i><tt>child</tt></i>.
notebookGetMenuLabelText :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m (Maybe Text)

-- | Gets the number of pages in a notebook.
--   
--   <i>Since: 2.2</i>
notebookGetNPages :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Int32

-- | Returns the child widget contained in page number
--   <i><tt>pageNum</tt></i>.
notebookGetNthPage :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Int32 -> m (Maybe Widget)

-- | Returns whether the tab label area has arrows for scrolling. See
--   <a>notebookSetScrollable</a>.
notebookGetScrollable :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Bool

-- | Returns whether a bevel will be drawn around the notebook pages. See
--   <a>notebookSetShowBorder</a>.
notebookGetShowBorder :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Bool

-- | Returns whether the tabs of the notebook are shown. See
--   <a>notebookSetShowTabs</a>.
notebookGetShowTabs :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Bool

-- | Returns whether the tab contents can be detached from
--   <i><tt>notebook</tt></i>.
--   
--   <i>Since: 2.10</i>
notebookGetTabDetachable :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m Bool

-- | Returns the horizontal width of a tab border.
--   
--   <i>Since: 2.22</i>
notebookGetTabHborder :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Word16

-- | Returns the tab label widget for the page <i><tt>child</tt></i>.
--   <a>Nothing</a> is returned if <i><tt>child</tt></i> is not in
--   <i><tt>notebook</tt></i> or if no tab label has specifically been set
--   for <i><tt>child</tt></i>.
notebookGetTabLabel :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m (Maybe Widget)

-- | Retrieves the text of the tab label for the page containing
--   <i><tt>child</tt></i>.
notebookGetTabLabelText :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m (Maybe Text)

-- | Gets the edge at which the tabs for switching pages in the notebook
--   are drawn.
notebookGetTabPos :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m PositionType

-- | Gets whether the tab can be reordered via drag and drop or not.
--   
--   <i>Since: 2.10</i>
notebookGetTabReorderable :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m Bool

-- | Returns the vertical width of a tab border.
--   
--   <i>Since: 2.22</i>
notebookGetTabVborder :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Word16

-- | Insert a page into <i><tt>notebook</tt></i> at the given position.
notebookInsertPage :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> Int32 -> m Int32

-- | Insert a page into <i><tt>notebook</tt></i> at the given position,
--   specifying the widget to use as the label in the popup menu.
notebookInsertPageMenu :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c, IsWidget d) => a -> b -> Maybe c -> Maybe d -> Int32 -> m Int32

-- | Switches to the next page. Nothing happens if the current page is the
--   last page.
notebookNextPage :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m ()

-- | Finds the index of the page which contains the given child widget.
notebookPageNum :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m Int32

-- | Disables the popup menu.
notebookPopupDisable :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m ()

-- | Enables the popup menu: if the user clicks with the right mouse button
--   on the tab labels, a menu with all the pages will be popped up.
notebookPopupEnable :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m ()

-- | Prepends a page to <i><tt>notebook</tt></i>.
notebookPrependPage :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m Int32

-- | Prepends a page to <i><tt>notebook</tt></i>, specifying the widget to
--   use as the label in the popup menu.
notebookPrependPageMenu :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c, IsWidget d) => a -> b -> Maybe c -> Maybe d -> m Int32

-- | Switches to the previous page. Nothing happens if the current page is
--   the first page.
notebookPrevPage :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m ()

-- | Removes a page from the notebook given its index in the notebook.
notebookRemovePage :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Int32 -> m ()

-- | Reorders the page containing <i><tt>child</tt></i>, so that it appears
--   in position <i><tt>position</tt></i>. If <i><tt>position</tt></i> is
--   greater than or equal to the number of children in the list or
--   negative, <i><tt>child</tt></i> will be moved to the end of the list.
notebookReorderChild :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Sets <i><tt>widget</tt></i> as one of the action widgets. Depending on
--   the pack type the widget will be placed before or after the tabs. You
--   can use a <a>Box</a> if you need to pack more than one widget on the
--   same side.
--   
--   Note that action widgets are “internal” children of the notebook and
--   thus not included in the list returned from <a>containerForeach</a>.
--   
--   <i>Since: 2.20</i>
notebookSetActionWidget :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> PackType -> m ()

-- | Switches to the page number <i><tt>pageNum</tt></i>.
--   
--   Note that due to historical reasons, GtkNotebook refuses to switch to
--   a page unless the child widget is visible. Therefore, it is
--   recommended to show child widgets before adding them to a notebook.
notebookSetCurrentPage :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Int32 -> m ()

-- | Sets a group name for <i><tt>notebook</tt></i>.
--   
--   Notebooks with the same name will be able to exchange tabs via drag
--   and drop. A notebook with a <a>Nothing</a> group name will not be able
--   to exchange tabs with any other notebook.
--   
--   <i>Since: 2.24</i>
notebookSetGroupName :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Maybe Text -> m ()

-- | Changes the menu label for the page containing <i><tt>child</tt></i>.
notebookSetMenuLabel :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m ()

-- | Creates a new label and sets it as the menu label of
--   <i><tt>child</tt></i>.
notebookSetMenuLabelText :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> Text -> m ()

-- | Sets whether the tab label area will have arrows for scrolling if
--   there are too many tabs to fit in the area.
notebookSetScrollable :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Bool -> m ()

-- | Sets whether a bevel will be drawn around the notebook pages. This
--   only has a visual effect when the tabs are not shown. See
--   <a>notebookSetShowTabs</a>.
notebookSetShowBorder :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Bool -> m ()

-- | Sets whether to show the tabs for the notebook or not.
notebookSetShowTabs :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Bool -> m ()

-- | Sets whether the tab can be detached from <i><tt>notebook</tt></i> to
--   another notebook or widget.
--   
--   Note that 2 notebooks must share a common group identificator (see
--   <a>notebookSetGroupName</a>) to allow automatic tabs interchange
--   between them.
--   
--   If you want a widget to interact with a notebook through DnD (i.e.:
--   accept dragged tabs from it) it must be set as a drop destination and
--   accept the target “GTK_NOTEBOOK_TAB”. The notebook will fill the
--   selection with a GtkWidget** pointing to the child widget that
--   corresponds to the dropped tab.
--   
--   Note that you should use <a>notebookDetachTab</a> instead of
--   <a>containerRemove</a> if you want to remove the tab from the source
--   notebook as part of accepting a drop. Otherwise, the source notebook
--   will think that the dragged tab was removed from underneath the
--   ongoing drag operation, and will initiate a drag cancel animation.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   static void
--   on_drag_data_received (GtkWidget        *widget,
--                          GdkDragContext   *context,
--                          gint              x,
--                          gint              y,
--                          GtkSelectionData *data,
--                          guint             info,
--                          guint             time,
--                          gpointer          user_data)
--   {
--     GtkWidget *notebook;
--     GtkWidget **child;
--   
--     notebook = gtk_drag_get_source_widget (context);
--     child = (void*) gtk_selection_data_get_data (data);
--   
--     // process_widget (*child);
--   
--     gtk_notebook_detach_tab (GTK_NOTEBOOK (notebook), *child);
--   }
--   </pre>
--   
--   If you want a notebook to accept drags from other widgets, you will
--   have to set your own DnD code to do it.
--   
--   <i>Since: 2.10</i>
notebookSetTabDetachable :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> Bool -> m ()

-- | Changes the tab label for <i><tt>child</tt></i>. If <a>Nothing</a> is
--   specified for <i><tt>tabLabel</tt></i>, then the page will have the
--   label “page N”.
notebookSetTabLabel :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m ()

-- | Creates a new label and sets it as the tab label for the page
--   containing <i><tt>child</tt></i>.
notebookSetTabLabelText :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> Text -> m ()

-- | Sets the edge at which the tabs for switching pages in the notebook
--   are drawn.
notebookSetTabPos :: (HasCallStack, MonadIO m, IsNotebook a) => a -> PositionType -> m ()

-- | Sets whether the notebook tab can be reordered via drag and drop or
--   not.
--   
--   <i>Since: 2.10</i>
notebookSetTabReorderable :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> Bool -> m ()

-- | Cast to <a>NativeDialog</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toNativeDialog :: (MonadIO m, IsNativeDialog o) => o -> m NativeDialog

-- | Connect a signal handler for the <a>response</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> nativeDialog #response callback
--   </pre>
onNativeDialogResponse :: (IsNativeDialog a, MonadIO m) => a -> ((?self :: a) => NativeDialogResponseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>response</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> nativeDialog #response callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNativeDialogResponse :: (IsNativeDialog a, MonadIO m) => a -> ((?self :: a) => NativeDialogResponseCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> nativeDialog #modal
--   </pre>
getNativeDialogModal :: (MonadIO m, IsNativeDialog o) => o -> m Bool

-- | Set the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> nativeDialog [ #modal <a>:=</a> value ]
--   </pre>
setNativeDialogModal :: (MonadIO m, IsNativeDialog o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>modal</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNativeDialogModal :: (IsNativeDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> nativeDialog #title
--   </pre>
getNativeDialogTitle :: (MonadIO m, IsNativeDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> nativeDialog [ #title <a>:=</a> value ]
--   </pre>
setNativeDialogTitle :: (MonadIO m, IsNativeDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNativeDialogTitle :: (IsNativeDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>transient-for</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> nativeDialog #transientFor
--   </pre>
getNativeDialogTransientFor :: (MonadIO m, IsNativeDialog o) => o -> m (Maybe Window)

-- | Set the value of the “<tt>transient-for</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> nativeDialog [ #transientFor <a>:=</a> value ]
--   </pre>
setNativeDialogTransientFor :: (MonadIO m, IsNativeDialog o, IsWindow a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>transient-for</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructNativeDialogTransientFor :: (IsNativeDialog o, MonadIO m, IsWindow a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>transient-for</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #transientFor
--   </pre>
clearNativeDialogTransientFor :: (MonadIO m, IsNativeDialog o) => o -> m ()

-- | Get the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> nativeDialog #visible
--   </pre>
getNativeDialogVisible :: (MonadIO m, IsNativeDialog o) => o -> m Bool

-- | Set the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> nativeDialog [ #visible <a>:=</a> value ]
--   </pre>
setNativeDialogVisible :: (MonadIO m, IsNativeDialog o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNativeDialogVisible :: (IsNativeDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Destroys a dialog.
--   
--   When a dialog is destroyed, it will break any references it holds to
--   other objects. If it is visible it will be hidden and any underlying
--   window system resources will be destroyed.
--   
--   Note that this does not release any reference to the object (as
--   opposed to destroying a GtkWindow) because there is no reference from
--   the windowing system to the <a>NativeDialog</a>.
--   
--   <i>Since: 3.20</i>
nativeDialogDestroy :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m ()

-- | Returns whether the dialog is modal. See <a>nativeDialogSetModal</a>.
--   
--   <i>Since: 3.20</i>
nativeDialogGetModal :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m Bool

-- | Gets the title of the <a>NativeDialog</a>.
--   
--   <i>Since: 3.20</i>
nativeDialogGetTitle :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m (Maybe Text)

-- | Fetches the transient parent for this window. See
--   <a>nativeDialogSetTransientFor</a>.
--   
--   <i>Since: 3.20</i>
nativeDialogGetTransientFor :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m (Maybe Window)

-- | Determines whether the dialog is visible.
--   
--   <i>Since: 3.20</i>
nativeDialogGetVisible :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m Bool

-- | Hides the dialog if it is visilbe, aborting any interaction. Once this
--   is called the <a>NativeDialog::response</a> signal will not be emitted
--   until after the next call to <a>nativeDialogShow</a>.
--   
--   If the dialog is not visible this does nothing.
--   
--   <i>Since: 3.20</i>
nativeDialogHide :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m ()

-- | Blocks in a recursive main loop until <i><tt>self</tt></i> emits the
--   <a>NativeDialog::response</a> signal. It then returns the response ID
--   from the <a>response</a> signal emission.
--   
--   Before entering the recursive main loop, <a>nativeDialogRun</a> calls
--   <a>nativeDialogShow</a> on the dialog for you.
--   
--   After <a>nativeDialogRun</a> returns, then dialog will be hidden.
--   
--   Typical usage of this function might be:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   gint result = gtk_native_dialog_run (GTK_NATIVE_DIALOG (dialog));
--   switch (result)
--     {
--       case GTK_RESPONSE_ACCEPT:
--          do_application_specific_something ();
--          break;
--       default:
--          do_nothing_since_dialog_was_cancelled ();
--          break;
--     }
--   g_object_unref (dialog);
--   </pre>
--   
--   Note that even though the recursive main loop gives the effect of a
--   modal dialog (it prevents the user from interacting with other windows
--   in the same window group while the dialog is run), callbacks such as
--   timeouts, IO channel watches, DND drops, etc, will be triggered during
--   a <a>nativeDialogRun</a> call.
--   
--   <i>Since: 3.20</i>
nativeDialogRun :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m Int32

-- | Sets a dialog modal or non-modal. Modal dialogs prevent interaction
--   with other windows in the same application. To keep modal dialogs on
--   top of main application windows, use
--   <a>nativeDialogSetTransientFor</a> to make the dialog transient for
--   the parent; most [window managers][gtk-X11-arch] will then disallow
--   lowering the dialog below the parent.
--   
--   <i>Since: 3.20</i>
nativeDialogSetModal :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> Bool -> m ()

-- | Sets the title of the <a>NativeDialog</a>.
--   
--   <i>Since: 3.20</i>
nativeDialogSetTitle :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> Text -> m ()

-- | Dialog windows should be set transient for the main application window
--   they were spawned from. This allows [window managers][gtk-X11-arch] to
--   e.g. keep the dialog on top of the main window, or center the dialog
--   over the main window.
--   
--   Passing <a>Nothing</a> for <i><tt>parent</tt></i> unsets the current
--   transient window.
--   
--   <i>Since: 3.20</i>
nativeDialogSetTransientFor :: (HasCallStack, MonadIO m, IsNativeDialog a, IsWindow b) => a -> Maybe b -> m ()

-- | Shows the dialog on the display, allowing the user to interact with
--   it. When the user accepts the state of the dialog the dialog will be
--   automatically hidden and the <a>NativeDialog::response</a> signal will
--   be emitted.
--   
--   Multiple calls while the dialog is visible will be ignored.
--   
--   <i>Since: 3.20</i>
nativeDialogShow :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m ()

-- | Cast to <a>MountOperation</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMountOperation :: (MonadIO m, IsMountOperation o) => o -> m MountOperation

-- | Get the value of the “<tt>is-showing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mountOperation #isShowing
--   </pre>
getMountOperationIsShowing :: (MonadIO m, IsMountOperation o) => o -> m Bool

-- | Get the value of the “<tt>parent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mountOperation #parent
--   </pre>
getMountOperationParent :: (MonadIO m, IsMountOperation o) => o -> m Window

-- | Set the value of the “<tt>parent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> mountOperation [ #parent <a>:=</a> value ]
--   </pre>
setMountOperationParent :: (MonadIO m, IsMountOperation o, IsWindow a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>parent</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMountOperationParent :: (IsMountOperation o, MonadIO m, IsWindow a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>parent</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #parent
--   </pre>
clearMountOperationParent :: (MonadIO m, IsMountOperation o) => o -> m ()

-- | Get the value of the “<tt>screen</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mountOperation #screen
--   </pre>
getMountOperationScreen :: (MonadIO m, IsMountOperation o) => o -> m Screen

-- | Set the value of the “<tt>screen</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> mountOperation [ #screen <a>:=</a> value ]
--   </pre>
setMountOperationScreen :: (MonadIO m, IsMountOperation o, IsScreen a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>screen</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMountOperationScreen :: (IsMountOperation o, MonadIO m, IsScreen a) => a -> m (GValueConstruct o)

-- | Creates a new <a>MountOperation</a>
--   
--   <i>Since: 2.14</i>
mountOperationNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> m MountOperation

-- | Gets the transient parent used by the <a>MountOperation</a>
--   
--   <i>Since: 2.14</i>
mountOperationGetParent :: (HasCallStack, MonadIO m, IsMountOperation a) => a -> m Window

-- | Gets the screen on which windows of the <a>MountOperation</a> will be
--   shown.
--   
--   <i>Since: 2.14</i>
mountOperationGetScreen :: (HasCallStack, MonadIO m, IsMountOperation a) => a -> m Screen

-- | Returns whether the <a>MountOperation</a> is currently displaying a
--   window.
--   
--   <i>Since: 2.14</i>
mountOperationIsShowing :: (HasCallStack, MonadIO m, IsMountOperation a) => a -> m Bool

-- | Sets the transient parent for windows shown by the
--   <a>MountOperation</a>.
--   
--   <i>Since: 2.14</i>
mountOperationSetParent :: (HasCallStack, MonadIO m, IsMountOperation a, IsWindow b) => a -> Maybe b -> m ()

-- | Sets the screen to show windows of the <a>MountOperation</a> on.
--   
--   <i>Since: 2.14</i>
mountOperationSetScreen :: (HasCallStack, MonadIO m, IsMountOperation a, IsScreen b) => a -> b -> m ()

-- | Cast to <a>Misc</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toMisc :: (MonadIO m, IsMisc o) => o -> m Misc

-- | Get the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> misc #xalign
--   </pre>
getMiscXalign :: (MonadIO m, IsMisc o) => o -> m Float

-- | Set the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> misc [ #xalign <a>:=</a> value ]
--   </pre>
setMiscXalign :: (MonadIO m, IsMisc o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>xalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMiscXalign :: (IsMisc o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>xpad</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> misc #xpad
--   </pre>
getMiscXpad :: (MonadIO m, IsMisc o) => o -> m Int32

-- | Set the value of the “<tt>xpad</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> misc [ #xpad <a>:=</a> value ]
--   </pre>
setMiscXpad :: (MonadIO m, IsMisc o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>xpad</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMiscXpad :: (IsMisc o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> misc #yalign
--   </pre>
getMiscYalign :: (MonadIO m, IsMisc o) => o -> m Float

-- | Set the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> misc [ #yalign <a>:=</a> value ]
--   </pre>
setMiscYalign :: (MonadIO m, IsMisc o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>yalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMiscYalign :: (IsMisc o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>ypad</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> misc #ypad
--   </pre>
getMiscYpad :: (MonadIO m, IsMisc o) => o -> m Int32

-- | Set the value of the “<tt>ypad</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> misc [ #ypad <a>:=</a> value ]
--   </pre>
setMiscYpad :: (MonadIO m, IsMisc o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ypad</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMiscYpad :: (IsMisc o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Gets the X and Y alignment of the widget within its allocation. See
--   <a>miscSetAlignment</a>.
miscGetAlignment :: (HasCallStack, MonadIO m, IsMisc a) => a -> m (Float, Float)

-- | Gets the padding in the X and Y directions of the widget. See
--   <a>miscSetPadding</a>.
miscGetPadding :: (HasCallStack, MonadIO m, IsMisc a) => a -> m (Int32, Int32)

-- | Sets the alignment of the widget.
miscSetAlignment :: (HasCallStack, MonadIO m, IsMisc a) => a -> Float -> Float -> m ()

-- | Sets the amount of space to add around the widget.
miscSetPadding :: (HasCallStack, MonadIO m, IsMisc a) => a -> Int32 -> Int32 -> m ()

-- | Cast to <a>LevelBar</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toLevelBar :: (MonadIO m, IsLevelBar o) => o -> m LevelBar

-- | Connect a signal handler for the <a>offsetChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> levelBar #offsetChanged callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to “<tt>offset-changed::detail</tt>”
--   instead.
onLevelBarOffsetChanged :: (IsLevelBar a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => LevelBarOffsetChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>offsetChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> levelBar #offsetChanged callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to “<tt>offset-changed::detail</tt>”
--   instead.
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterLevelBarOffsetChanged :: (IsLevelBar a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => LevelBarOffsetChangedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> levelBar #inverted
--   </pre>
getLevelBarInverted :: (MonadIO m, IsLevelBar o) => o -> m Bool

-- | Set the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> levelBar [ #inverted <a>:=</a> value ]
--   </pre>
setLevelBarInverted :: (MonadIO m, IsLevelBar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inverted</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLevelBarInverted :: (IsLevelBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> levelBar #maxValue
--   </pre>
getLevelBarMaxValue :: (MonadIO m, IsLevelBar o) => o -> m Double

-- | Set the value of the “<tt>max-value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> levelBar [ #maxValue <a>:=</a> value ]
--   </pre>
setLevelBarMaxValue :: (MonadIO m, IsLevelBar o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-value</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLevelBarMaxValue :: (IsLevelBar o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>min-value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> levelBar #minValue
--   </pre>
getLevelBarMinValue :: (MonadIO m, IsLevelBar o) => o -> m Double

-- | Set the value of the “<tt>min-value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> levelBar [ #minValue <a>:=</a> value ]
--   </pre>
setLevelBarMinValue :: (MonadIO m, IsLevelBar o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>min-value</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLevelBarMinValue :: (IsLevelBar o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>mode</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> levelBar #mode
--   </pre>
getLevelBarMode :: (MonadIO m, IsLevelBar o) => o -> m LevelBarMode

-- | Set the value of the “<tt>mode</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> levelBar [ #mode <a>:=</a> value ]
--   </pre>
setLevelBarMode :: (MonadIO m, IsLevelBar o) => o -> LevelBarMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>mode</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLevelBarMode :: (IsLevelBar o, MonadIO m) => LevelBarMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> levelBar #value
--   </pre>
getLevelBarValue :: (MonadIO m, IsLevelBar o) => o -> m Double

-- | Set the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> levelBar [ #value <a>:=</a> value ]
--   </pre>
setLevelBarValue :: (MonadIO m, IsLevelBar o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>value</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLevelBarValue :: (IsLevelBar o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Creates a new <a>LevelBar</a>.
--   
--   <i>Since: 3.6</i>
levelBarNew :: (HasCallStack, MonadIO m) => m LevelBar

-- | Utility constructor that creates a new <a>LevelBar</a> for the
--   specified interval.
--   
--   <i>Since: 3.6</i>
levelBarNewForInterval :: (HasCallStack, MonadIO m) => Double -> Double -> m LevelBar

-- | Adds a new offset marker on <i><tt>self</tt></i> at the position
--   specified by <i><tt>value</tt></i>. When the bar value is in the
--   interval topped by <i><tt>value</tt></i> (or between
--   <i><tt>value</tt></i> and <a>LevelBar:maxValue</a> in case the offset
--   is the last one on the bar) a style class named
--   <tt>level-</tt><i><tt>name</tt></i> will be applied when rendering the
--   level bar fill. If another offset marker named <i><tt>name</tt></i>
--   exists, its value will be replaced by <i><tt>value</tt></i>.
--   
--   <i>Since: 3.6</i>
levelBarAddOffsetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Text -> Double -> m ()

-- | Return the value of the <a>LevelBar:inverted</a> property.
--   
--   <i>Since: 3.8</i>
levelBarGetInverted :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> m Bool

-- | Returns the value of the <a>LevelBar:maxValue</a> property.
--   
--   <i>Since: 3.6</i>
levelBarGetMaxValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> m Double

-- | Returns the value of the <a>LevelBar:minValue</a> property.
--   
--   <i>Since: 3.6</i>
levelBarGetMinValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> m Double

-- | Returns the value of the <a>LevelBar:mode</a> property.
--   
--   <i>Since: 3.6</i>
levelBarGetMode :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> m LevelBarMode

-- | Fetches the value specified for the offset marker <i><tt>name</tt></i>
--   in <i><tt>self</tt></i>, returning <a>True</a> in case an offset named
--   <i><tt>name</tt></i> was found.
--   
--   <i>Since: 3.6</i>
levelBarGetOffsetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Maybe Text -> m (Bool, Double)

-- | Returns the value of the <a>LevelBar:value</a> property.
--   
--   <i>Since: 3.6</i>
levelBarGetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> m Double

-- | Removes an offset marker previously added with
--   <a>levelBarAddOffsetValue</a>.
--   
--   <i>Since: 3.6</i>
levelBarRemoveOffsetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Maybe Text -> m ()

-- | Sets the value of the <a>LevelBar:inverted</a> property.
--   
--   <i>Since: 3.8</i>
levelBarSetInverted :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Bool -> m ()

-- | Sets the value of the <a>LevelBar:maxValue</a> property.
--   
--   You probably want to update preexisting level offsets after calling
--   this function.
--   
--   <i>Since: 3.6</i>
levelBarSetMaxValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Double -> m ()

-- | Sets the value of the <a>LevelBar:minValue</a> property.
--   
--   You probably want to update preexisting level offsets after calling
--   this function.
--   
--   <i>Since: 3.6</i>
levelBarSetMinValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Double -> m ()

-- | Sets the value of the <a>LevelBar:mode</a> property.
--   
--   <i>Since: 3.6</i>
levelBarSetMode :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> LevelBarMode -> m ()

-- | Sets the value of the <a>LevelBar:value</a> property.
--   
--   <i>Since: 3.6</i>
levelBarSetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Double -> m ()

-- | Cast to <a>Layout</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toLayout :: (MonadIO m, IsLayout o) => o -> m Layout

-- | Get the value of the “<tt>height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> layout #height
--   </pre>
getLayoutHeight :: (MonadIO m, IsLayout o) => o -> m Word32

-- | Set the value of the “<tt>height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> layout [ #height <a>:=</a> value ]
--   </pre>
setLayoutHeight :: (MonadIO m, IsLayout o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>height</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLayoutHeight :: (IsLayout o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> layout #width
--   </pre>
getLayoutWidth :: (MonadIO m, IsLayout o) => o -> m Word32

-- | Set the value of the “<tt>width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> layout [ #width <a>:=</a> value ]
--   </pre>
setLayoutWidth :: (MonadIO m, IsLayout o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>width</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLayoutWidth :: (IsLayout o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Creates a new <a>Layout</a>. Unless you have a specific adjustment
--   you’d like the layout to use for scrolling, pass <a>Nothing</a> for
--   <i><tt>hadjustment</tt></i> and <i><tt>vadjustment</tt></i>.
layoutNew :: (HasCallStack, MonadIO m, IsAdjustment a, IsAdjustment b) => Maybe a -> Maybe b -> m Layout

-- | Retrieve the bin window of the layout used for drawing operations.
--   
--   <i>Since: 2.14</i>
layoutGetBinWindow :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Window

-- | This function should only be called after the layout has been placed
--   in a <a>ScrolledWindow</a> or otherwise configured for scrolling. It
--   returns the <a>Adjustment</a> used for communication between the
--   horizontal scrollbar and <i><tt>layout</tt></i>.
--   
--   See <a>ScrolledWindow</a>, <a>Scrollbar</a>, <a>Adjustment</a> for
--   details.
layoutGetHadjustment :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Adjustment

-- | Gets the size that has been set on the layout, and that determines the
--   total extents of the layout’s scrollbar area. See gtk_layout_set_size
--   ().
layoutGetSize :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Word32, Word32)

-- | This function should only be called after the layout has been placed
--   in a <a>ScrolledWindow</a> or otherwise configured for scrolling. It
--   returns the <a>Adjustment</a> used for communication between the
--   vertical scrollbar and <i><tt>layout</tt></i>.
--   
--   See <a>ScrolledWindow</a>, <a>Scrollbar</a>, <a>Adjustment</a> for
--   details.
layoutGetVadjustment :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Adjustment

-- | Moves a current child of <i><tt>layout</tt></i> to a new position.
layoutMove :: (HasCallStack, MonadIO m, IsLayout a, IsWidget b) => a -> b -> Int32 -> Int32 -> m ()

-- | Adds <i><tt>childWidget</tt></i> to <i><tt>layout</tt></i>, at
--   position (<i><tt>x</tt></i>,<i><tt>y</tt></i>). <i><tt>layout</tt></i>
--   becomes the new parent container of <i><tt>childWidget</tt></i>.
layoutPut :: (HasCallStack, MonadIO m, IsLayout a, IsWidget b) => a -> b -> Int32 -> Int32 -> m ()

-- | Sets the horizontal scroll adjustment for the layout.
--   
--   See <a>ScrolledWindow</a>, <a>Scrollbar</a>, <a>Adjustment</a> for
--   details.
layoutSetHadjustment :: (HasCallStack, MonadIO m, IsLayout a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Sets the size of the scrollable area of the layout.
layoutSetSize :: (HasCallStack, MonadIO m, IsLayout a) => a -> Word32 -> Word32 -> m ()

-- | Sets the vertical scroll adjustment for the layout.
--   
--   See <a>ScrolledWindow</a>, <a>Scrollbar</a>, <a>Adjustment</a> for
--   details.
layoutSetVadjustment :: (HasCallStack, MonadIO m, IsLayout a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Cast to <a>Invisible</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toInvisible :: (MonadIO m, IsInvisible o) => o -> m Invisible

-- | Get the value of the “<tt>screen</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> invisible #screen
--   </pre>
getInvisibleScreen :: (MonadIO m, IsInvisible o) => o -> m Screen

-- | Set the value of the “<tt>screen</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> invisible [ #screen <a>:=</a> value ]
--   </pre>
setInvisibleScreen :: (MonadIO m, IsInvisible o, IsScreen a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>screen</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructInvisibleScreen :: (IsInvisible o, MonadIO m, IsScreen a) => a -> m (GValueConstruct o)

-- | Creates a new <a>Invisible</a>.
invisibleNew :: (HasCallStack, MonadIO m) => m Invisible

-- | Creates a new <a>Invisible</a> object for a specified screen
--   
--   <i>Since: 2.2</i>
invisibleNewForScreen :: (HasCallStack, MonadIO m, IsScreen a) => a -> m Invisible

-- | Returns the <a>Screen</a> object associated with
--   <i><tt>invisible</tt></i>
--   
--   <i>Since: 2.2</i>
invisibleGetScreen :: (HasCallStack, MonadIO m, IsInvisible a) => a -> m Screen

-- | Sets the <a>Screen</a> where the <a>Invisible</a> object will be
--   displayed.
--   
--   <i>Since: 2.2</i>
invisibleSetScreen :: (HasCallStack, MonadIO m, IsInvisible a, IsScreen b) => a -> b -> m ()

-- | Cast to <a>Image</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toImage :: (MonadIO m, IsImage o) => o -> m Image

-- | Get the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #file
--   </pre>
getImageFile :: (MonadIO m, IsImage o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #file <a>:=</a> value ]
--   </pre>
setImageFile :: (MonadIO m, IsImage o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>file</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructImageFile :: (IsImage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>file</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #file
--   </pre>
clearImageFile :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “<tt>gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #gicon
--   </pre>
getImageGicon :: (MonadIO m, IsImage o) => o -> m (Maybe Icon)

-- | Set the value of the “<tt>gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #gicon <a>:=</a> value ]
--   </pre>
setImageGicon :: (MonadIO m, IsImage o, IsIcon a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gicon</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructImageGicon :: (IsImage o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>gicon</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #gicon
--   </pre>
clearImageGicon :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #iconName
--   </pre>
getImageIconName :: (MonadIO m, IsImage o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #iconName <a>:=</a> value ]
--   </pre>
setImageIconName :: (MonadIO m, IsImage o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructImageIconName :: (IsImage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>icon-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #iconName
--   </pre>
clearImageIconName :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “<tt>icon-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #iconSet
--   </pre>
getImageIconSet :: (MonadIO m, IsImage o) => o -> m (Maybe IconSet)

-- | Set the value of the “<tt>icon-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #iconSet <a>:=</a> value ]
--   </pre>
setImageIconSet :: (MonadIO m, IsImage o) => o -> IconSet -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructImageIconSet :: (IsImage o, MonadIO m) => IconSet -> m (GValueConstruct o)

-- | Set the value of the “<tt>icon-set</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #iconSet
--   </pre>
clearImageIconSet :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “<tt>icon-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #iconSize
--   </pre>
getImageIconSize :: (MonadIO m, IsImage o) => o -> m Int32

-- | Set the value of the “<tt>icon-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #iconSize <a>:=</a> value ]
--   </pre>
setImageIconSize :: (MonadIO m, IsImage o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-size</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructImageIconSize :: (IsImage o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixbuf</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #pixbuf
--   </pre>
getImagePixbuf :: (MonadIO m, IsImage o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “<tt>pixbuf</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #pixbuf <a>:=</a> value ]
--   </pre>
setImagePixbuf :: (MonadIO m, IsImage o, IsPixbuf a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixbuf</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructImagePixbuf :: (IsImage o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>pixbuf</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #pixbuf
--   </pre>
clearImagePixbuf :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “<tt>pixbuf-animation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #pixbufAnimation
--   </pre>
getImagePixbufAnimation :: (MonadIO m, IsImage o) => o -> m (Maybe PixbufAnimation)

-- | Set the value of the “<tt>pixbuf-animation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #pixbufAnimation <a>:=</a> value ]
--   </pre>
setImagePixbufAnimation :: (MonadIO m, IsImage o, IsPixbufAnimation a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixbuf-animation</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructImagePixbufAnimation :: (IsImage o, MonadIO m, IsPixbufAnimation a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>pixbuf-animation</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #pixbufAnimation
--   </pre>
clearImagePixbufAnimation :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “<tt>pixel-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #pixelSize
--   </pre>
getImagePixelSize :: (MonadIO m, IsImage o) => o -> m Int32

-- | Set the value of the “<tt>pixel-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #pixelSize <a>:=</a> value ]
--   </pre>
setImagePixelSize :: (MonadIO m, IsImage o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixel-size</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructImagePixelSize :: (IsImage o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>resource</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #resource
--   </pre>
getImageResource :: (MonadIO m, IsImage o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>resource</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #resource <a>:=</a> value ]
--   </pre>
setImageResource :: (MonadIO m, IsImage o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>resource</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructImageResource :: (IsImage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>resource</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #resource
--   </pre>
clearImageResource :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “<tt>stock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #stock
--   </pre>
getImageStock :: (MonadIO m, IsImage o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>stock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #stock <a>:=</a> value ]
--   </pre>
setImageStock :: (MonadIO m, IsImage o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stock</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructImageStock :: (IsImage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>stock</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #stock
--   </pre>
clearImageStock :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “<tt>storage-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #storageType
--   </pre>
getImageStorageType :: (MonadIO m, IsImage o) => o -> m ImageType

-- | Get the value of the “<tt>surface</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #surface
--   </pre>
getImageSurface :: (MonadIO m, IsImage o) => o -> m (Maybe Surface)

-- | Set the value of the “<tt>surface</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #surface <a>:=</a> value ]
--   </pre>
setImageSurface :: (MonadIO m, IsImage o) => o -> Surface -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>surface</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructImageSurface :: (IsImage o, MonadIO m) => Surface -> m (GValueConstruct o)

-- | Set the value of the “<tt>surface</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #surface
--   </pre>
clearImageSurface :: (MonadIO m, IsImage o) => o -> m ()

-- | Get the value of the “<tt>use-fallback</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #useFallback
--   </pre>
getImageUseFallback :: (MonadIO m, IsImage o) => o -> m Bool

-- | Set the value of the “<tt>use-fallback</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #useFallback <a>:=</a> value ]
--   </pre>
setImageUseFallback :: (MonadIO m, IsImage o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-fallback</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructImageUseFallback :: (IsImage o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new empty <a>Image</a> widget.
imageNew :: (HasCallStack, MonadIO m) => m Image

-- | Creates a <a>Image</a> displaying the given animation. The
--   <a>Image</a> does not assume a reference to the animation; you still
--   need to unref it if you own references. <a>Image</a> will add its own
--   reference rather than adopting yours.
--   
--   Note that the animation frames are shown using a timeout with
--   <a>PRIORITY_DEFAULT</a>. When using animations to indicate busyness,
--   keep in mind that the animation will only be shown if the main loop is
--   not busy with something that has a higher priority.
imageNewFromAnimation :: (HasCallStack, MonadIO m, IsPixbufAnimation a) => a -> m Image

-- | Creates a new <a>Image</a> displaying the file
--   <i><tt>filename</tt></i>. If the file isn’t found or can’t be loaded,
--   the resulting <a>Image</a> will display a “broken image” icon. This
--   function never returns <a>Nothing</a>, it always returns a valid
--   <a>Image</a> widget.
--   
--   If the file contains an animation, the image will contain an
--   animation.
--   
--   If you need to detect failures to load the file, use
--   <a>pixbufNewFromFile</a> to load the file yourself, then create the
--   <a>Image</a> from the pixbuf. (Or for animations, use
--   <a>pixbufAnimationNewFromFile</a>).
--   
--   The storage type (<a>imageGetStorageType</a>) of the returned image is
--   not defined, it will be whatever is appropriate for displaying the
--   file.
imageNewFromFile :: (HasCallStack, MonadIO m) => [Char] -> m Image

-- | Creates a <a>Image</a> displaying an icon from the current icon theme.
--   If the icon name isn’t known, a “broken image” icon will be displayed
--   instead. If the current icon theme is changed, the icon will be
--   updated appropriately.
--   
--   <i>Since: 2.14</i>
imageNewFromGicon :: (HasCallStack, MonadIO m, IsIcon a) => a -> Int32 -> m Image

-- | Creates a <a>Image</a> displaying an icon from the current icon theme.
--   If the icon name isn’t known, a “broken image” icon will be displayed
--   instead. If the current icon theme is changed, the icon will be
--   updated appropriately.
--   
--   <i>Since: 2.6</i>
imageNewFromIconName :: (HasCallStack, MonadIO m) => Maybe Text -> Int32 -> m Image

-- | Creates a <a>Image</a> displaying an icon set. Sample stock sizes are
--   <tt><i>GTK_ICON_SIZE_MENU</i></tt>,
--   <tt><i>GTK_ICON_SIZE_SMALL_TOOLBAR</i></tt>. Instead of using this
--   function, usually it’s better to create a <a>IconFactory</a>, put your
--   icon sets in the icon factory, add the icon factory to the list of
--   default factories with <a>iconFactoryAddDefault</a>, and then use
--   <a>imageNewFromStock</a>. This will allow themes to override the icon
--   you ship with your application.
--   
--   The <a>Image</a> does not assume a reference to the icon set; you
--   still need to unref it if you own references. <a>Image</a> will add
--   its own reference rather than adopting yours.
imageNewFromIconSet :: (HasCallStack, MonadIO m) => IconSet -> Int32 -> m Image

-- | Creates a new <a>Image</a> displaying <i><tt>pixbuf</tt></i>. The
--   <a>Image</a> does not assume a reference to the pixbuf; you still need
--   to unref it if you own references. <a>Image</a> will add its own
--   reference rather than adopting yours.
--   
--   Note that this function just creates an <a>Image</a> from the pixbuf.
--   The <a>Image</a> created will not react to state changes. Should you
--   want that, you should use <a>imageNewFromIconName</a>.
imageNewFromPixbuf :: (HasCallStack, MonadIO m, IsPixbuf a) => Maybe a -> m Image

-- | Creates a new <a>Image</a> displaying the resource file
--   <i><tt>resourcePath</tt></i>. If the file isn’t found or can’t be
--   loaded, the resulting <a>Image</a> will display a “broken image” icon.
--   This function never returns <a>Nothing</a>, it always returns a valid
--   <a>Image</a> widget.
--   
--   If the file contains an animation, the image will contain an
--   animation.
--   
--   If you need to detect failures to load the file, use
--   <a>pixbufNewFromFile</a> to load the file yourself, then create the
--   <a>Image</a> from the pixbuf. (Or for animations, use
--   <a>pixbufAnimationNewFromFile</a>).
--   
--   The storage type (<a>imageGetStorageType</a>) of the returned image is
--   not defined, it will be whatever is appropriate for displaying the
--   file.
--   
--   <i>Since: 3.4</i>
imageNewFromResource :: (HasCallStack, MonadIO m) => Text -> m Image

-- | Creates a new <a>Image</a> displaying <i><tt>surface</tt></i>. The
--   <a>Image</a> does not assume a reference to the surface; you still
--   need to unref it if you own references. <a>Image</a> will add its own
--   reference rather than adopting yours.
--   
--   <i>Since: 3.10</i>
imageNewFromSurface :: (HasCallStack, MonadIO m) => Maybe Surface -> m Image

-- | Resets the image to be empty.
--   
--   <i>Since: 2.8</i>
imageClear :: (HasCallStack, MonadIO m, IsImage a) => a -> m ()

-- | Gets the <a>PixbufAnimation</a> being displayed by the <a>Image</a>.
--   The storage type of the image must be <a>ImageTypeEmpty</a> or
--   <a>ImageTypeAnimation</a> (see <a>imageGetStorageType</a>). The caller
--   of this function does not own a reference to the returned animation.
imageGetAnimation :: (HasCallStack, MonadIO m, IsImage a) => a -> m (Maybe PixbufAnimation)

-- | Gets the <a>Icon</a> and size being displayed by the <a>Image</a>. The
--   storage type of the image must be <a>ImageTypeEmpty</a> or
--   <a>ImageTypeGicon</a> (see <a>imageGetStorageType</a>). The caller of
--   this function does not own a reference to the returned <a>Icon</a>.
--   
--   <i>Since: 2.14</i>
imageGetGicon :: (HasCallStack, MonadIO m, IsImage a) => a -> m (Icon, Int32)

-- | Gets the icon name and size being displayed by the <a>Image</a>. The
--   storage type of the image must be <a>ImageTypeEmpty</a> or
--   <a>ImageTypeIconName</a> (see <a>imageGetStorageType</a>). The
--   returned string is owned by the <a>Image</a> and should not be freed.
--   
--   <i>Since: 2.6</i>
imageGetIconName :: (HasCallStack, MonadIO m, IsImage a) => a -> m (Text, Int32)

-- | Gets the icon set and size being displayed by the <a>Image</a>. The
--   storage type of the image must be <a>ImageTypeEmpty</a> or
--   <a>ImageTypeIconSet</a> (see <a>imageGetStorageType</a>).
imageGetIconSet :: (HasCallStack, MonadIO m, IsImage a) => a -> m (IconSet, Int32)

-- | Gets the pixel size used for named icons.
--   
--   <i>Since: 2.6</i>
imageGetPixelSize :: (HasCallStack, MonadIO m, IsImage a) => a -> m Int32

-- | Causes the <a>Image</a> to display the given animation (or display
--   nothing, if you set the animation to <a>Nothing</a>).
imageSetFromAnimation :: (HasCallStack, MonadIO m, IsImage a, IsPixbufAnimation b) => a -> b -> m ()

-- | See <a>imageNewFromFile</a> for details.
imageSetFromFile :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe [Char] -> m ()

-- | See <a>imageNewFromGicon</a> for details.
--   
--   <i>Since: 2.14</i>
imageSetFromGicon :: (HasCallStack, MonadIO m, IsImage a, IsIcon b) => a -> b -> Int32 -> m ()

-- | See <a>imageNewFromIconName</a> for details.
--   
--   <i>Since: 2.6</i>
imageSetFromIconName :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe Text -> Int32 -> m ()

-- | See <a>imageNewFromIconSet</a> for details.
imageSetFromIconSet :: (HasCallStack, MonadIO m, IsImage a) => a -> IconSet -> Int32 -> m ()

-- | See <a>imageNewFromPixbuf</a> for details.
imageSetFromPixbuf :: (HasCallStack, MonadIO m, IsImage a, IsPixbuf b) => a -> Maybe b -> m ()

-- | See <a>imageNewFromResource</a> for details.
imageSetFromResource :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe Text -> m ()

-- | See <a>imageNewFromStock</a> for details.
imageSetFromStock :: (HasCallStack, MonadIO m, IsImage a) => a -> Text -> Int32 -> m ()

-- | See <a>imageNewFromSurface</a> for details.
--   
--   <i>Since: 3.10</i>
imageSetFromSurface :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe Surface -> m ()

-- | Sets the pixel size to use for named icons. If the pixel size is set
--   to a value != -1, it is used instead of the icon size set by
--   <a>imageSetFromIconName</a>.
--   
--   <i>Since: 2.6</i>
imageSetPixelSize :: (HasCallStack, MonadIO m, IsImage a) => a -> Int32 -> m ()

-- | Cast to <a>IconTheme</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toIconTheme :: (MonadIO m, IsIconTheme o) => o -> m IconTheme

-- | Cast to <a>IconInfo</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toIconInfo :: (MonadIO m, IsIconInfo o) => o -> m IconInfo

-- | Creates a <a>IconInfo</a> for a <a>Pixbuf</a>.
--   
--   <i>Since: 2.14</i>
iconInfoNewForPixbuf :: (HasCallStack, MonadIO m, IsIconTheme a, IsPixbuf b) => a -> b -> m IconInfo

-- | This function is deprecated and always returns <a>False</a>.
--   
--   <i>Since: 2.4</i>
iconInfoGetAttachPoints :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m (Bool, [Point])

-- | Gets the base scale for the icon. The base scale is a scale for the
--   icon that was specified by the icon theme creator. For instance an
--   icon drawn for a high-dpi screen with window scale 2 for a base size
--   of 32 will be 64 pixels tall and have a base scale of 2.
--   
--   <i>Since: 3.10</i>
iconInfoGetBaseScale :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m Int32

-- | Gets the base size for the icon. The base size is a size for the icon
--   that was specified by the icon theme creator. This may be different
--   than the actual size of image; an example of this is small emblem
--   icons that can be attached to a larger icon. These icons will be given
--   the same base size as the larger icons to which they are attached.
--   
--   Note that for scaled icons the base size does not include the base
--   scale.
--   
--   <i>Since: 2.4</i>
iconInfoGetBaseSize :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m Int32

-- | This function is deprecated and always returns <a>Nothing</a>.
--   
--   <i>Since: 2.4</i>
iconInfoGetDisplayName :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m Text

-- | This function is deprecated and always returns <a>False</a>.
--   
--   <i>Since: 2.4</i>
iconInfoGetEmbeddedRect :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m (Bool, Rectangle)

-- | Checks if the icon is symbolic or not. This currently uses only the
--   file name and not the file contents for determining this. This
--   behaviour may change in the future.
--   
--   <i>Since: 3.12</i>
iconInfoIsSymbolic :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> m Bool

-- | Asynchronously load, render and scale an icon previously looked up
--   from the icon theme using <a>iconThemeLookupIcon</a>.
--   
--   For more details, see <a>iconInfoLoadIcon</a> which is the synchronous
--   version of this call.
--   
--   <i>Since: 3.8</i>
iconInfoLoadIconAsync :: (HasCallStack, MonadIO m, IsIconInfo a, IsCancellable b) => a -> Maybe b -> Maybe AsyncReadyCallback -> m ()

-- | Finishes an async icon load, see <a>iconInfoLoadIconAsync</a>.
--   
--   <i>Since: 3.8</i>
iconInfoLoadIconFinish :: (HasCallStack, MonadIO m, IsIconInfo a, IsAsyncResult b) => a -> b -> m Pixbuf

-- | Loads an icon, modifying it to match the system colours for the
--   foreground, success, warning and error colors provided. If the icon is
--   not a symbolic one, the function will return the result from
--   <a>iconInfoLoadIcon</a>.
--   
--   This allows loading symbolic icons that will match the system theme.
--   
--   Unless you are implementing a widget, you will want to use
--   <a>themedIconNewWithDefaultFallbacks</a> to load the icon.
--   
--   As implementation details, the icon loaded needs to be of SVG type,
--   contain the “symbolic” term as the last component of the icon name,
--   and use the “fg”, “success”, “warning” and “error” CSS styles in the
--   SVG file itself.
--   
--   See the <a>Symbolic Icons Specification</a> for more information about
--   symbolic icons.
--   
--   <i>Since: 3.0</i>
iconInfoLoadSymbolic :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> RGBA -> Maybe RGBA -> Maybe RGBA -> Maybe RGBA -> m (Pixbuf, Bool)

-- | Asynchronously load, render and scale a symbolic icon previously
--   looked up from the icon theme using <a>iconThemeLookupIcon</a>.
--   
--   For more details, see <a>iconInfoLoadSymbolic</a> which is the
--   synchronous version of this call.
--   
--   <i>Since: 3.8</i>
iconInfoLoadSymbolicAsync :: (HasCallStack, MonadIO m, IsIconInfo a, IsCancellable b) => a -> RGBA -> Maybe RGBA -> Maybe RGBA -> Maybe RGBA -> Maybe b -> Maybe AsyncReadyCallback -> m ()

-- | Finishes an async icon load, see <a>iconInfoLoadSymbolicAsync</a>.
--   
--   <i>Since: 3.8</i>
iconInfoLoadSymbolicFinish :: (HasCallStack, MonadIO m, IsIconInfo a, IsAsyncResult b) => a -> b -> m (Pixbuf, Bool)

-- | Loads an icon, modifying it to match the system colors for the
--   foreground, success, warning and error colors provided. If the icon is
--   not a symbolic one, the function will return the result from
--   <a>iconInfoLoadIcon</a>. This function uses the regular foreground
--   color and the symbolic colors with the names “success_color”,
--   “warning_color” and “error_color” from the context.
--   
--   This allows loading symbolic icons that will match the system theme.
--   
--   See <a>iconInfoLoadSymbolic</a> for more details.
--   
--   <i>Since: 3.0</i>
iconInfoLoadSymbolicForContext :: (HasCallStack, MonadIO m, IsIconInfo a, IsStyleContext b) => a -> b -> m (Pixbuf, Bool)

-- | Asynchronously load, render and scale a symbolic icon previously
--   looked up from the icon theme using <a>iconThemeLookupIcon</a>.
--   
--   For more details, see <a>iconInfoLoadSymbolicForContext</a> which is
--   the synchronous version of this call.
--   
--   <i>Since: 3.8</i>
iconInfoLoadSymbolicForContextAsync :: (HasCallStack, MonadIO m, IsIconInfo a, IsStyleContext b, IsCancellable c) => a -> b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finishes an async icon load, see
--   <a>iconInfoLoadSymbolicForContextAsync</a>.
--   
--   <i>Since: 3.8</i>
iconInfoLoadSymbolicForContextFinish :: (HasCallStack, MonadIO m, IsIconInfo a, IsAsyncResult b) => a -> b -> m (Pixbuf, Bool)

-- | Loads an icon, modifying it to match the system colours for the
--   foreground, success, warning and error colors provided. If the icon is
--   not a symbolic one, the function will return the result from
--   <a>iconInfoLoadIcon</a>.
--   
--   This allows loading symbolic icons that will match the system theme.
--   
--   See <a>iconInfoLoadSymbolic</a> for more details.
--   
--   <i>Since: 3.0</i>
iconInfoLoadSymbolicForStyle :: (HasCallStack, MonadIO m, IsIconInfo a, IsStyle b) => a -> b -> StateType -> m (Pixbuf, Bool)

-- | Sets whether the coordinates returned by
--   <a>iconInfoGetEmbeddedRect</a> and <a>iconInfoGetAttachPoints</a>
--   should be returned in their original form as specified in the icon
--   theme, instead of scaled appropriately for the pixbuf returned by
--   <a>iconInfoLoadIcon</a>.
--   
--   Raw coordinates are somewhat strange; they are specified to be with
--   respect to the unscaled pixmap for PNG and XPM icons, but for SVG
--   icons, they are in a 1000x1000 coordinate space that is scaled to the
--   final size of the icon. You can determine if the icon is an SVG icon
--   by using <a>iconInfoGetFilename</a>, and seeing if it is
--   non-<a>Nothing</a> and ends in “.svg”.
--   
--   This function is provided primarily to allow compatibility wrappers
--   for older API's, and is not expected to be useful for applications.
--   
--   <i>Since: 2.4</i>
iconInfoSetRawCoordinates :: (HasCallStack, MonadIO m, IsIconInfo a) => a -> Bool -> m ()

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> iconTheme #changed callback
--   </pre>
onIconThemeChanged :: (IsIconTheme a, MonadIO m) => a -> ((?self :: a) => IconThemeChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> iconTheme #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconThemeChanged :: (IsIconTheme a, MonadIO m) => a -> ((?self :: a) => IconThemeChangedCallback) -> m SignalHandlerId

-- | Creates a new icon theme object. Icon theme objects are used to lookup
--   up an icon by name in a particular icon theme. Usually, you’ll want to
--   use <a>iconThemeGetDefault</a> or <a>iconThemeGetForScreen</a> rather
--   than creating a new icon theme object for scratch.
--   
--   <i>Since: 2.4</i>
iconThemeNew :: (HasCallStack, MonadIO m) => m IconTheme

-- | Adds a resource path that will be looked at when looking for icons,
--   similar to search paths.
--   
--   This function should be used to make application-specific icons
--   available as part of the icon theme.
--   
--   The resources are considered as part of the hicolor icon theme and
--   must be located in subdirectories that are defined in the hicolor icon
--   theme, such as <tt>@path/16x16/actions/run.png</tt>. Icons that are
--   directly placed in the resource path instead of a subdirectory are
--   also considered as ultimate fallback.
--   
--   <i>Since: 3.14</i>
iconThemeAddResourcePath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> m ()

-- | Appends a directory to the search path. See
--   <a>iconThemeSetSearchPath</a>.
--   
--   <i>Since: 2.4</i>
iconThemeAppendSearchPath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> [Char] -> m ()

-- | Looks up a named icon for a particular window scale and returns a
--   <a>IconInfo</a> containing information such as the filename of the
--   icon. The icon can then be rendered into a pixbuf using
--   <a>iconInfoLoadIcon</a>. (<a>iconThemeLoadIcon</a> combines these two
--   steps if all you need is the pixbuf.)
--   
--   If <i><tt>iconNames</tt></i> contains more than one name, this
--   function tries them all in the given order before falling back to
--   inherited icon themes.
--   
--   <i>Since: 3.10</i>
iconThemeChooseIconForScale :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> [Text] -> Int32 -> Int32 -> [IconLookupFlags] -> m (Maybe IconInfo)

-- | Gets the name of an icon that is representative of the current theme
--   (for instance, to use when presenting a list of themes to the user.)
--   
--   <i>Since: 2.4</i>
iconThemeGetExampleIconName :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> m (Maybe Text)

-- | Returns an array of integers describing the sizes at which the icon is
--   available without scaling. A size of -1 means that the icon is
--   available in a scalable format. The array is zero-terminated.
--   
--   <i>Since: 2.6</i>
iconThemeGetIconSizes :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> m [Int32]

-- | Gets the current search path. See <a>iconThemeSetSearchPath</a>.
--   
--   <i>Since: 2.4</i>
iconThemeGetSearchPath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> m [[Char]]

-- | Checks whether an icon theme includes an icon for a particular name.
--   
--   <i>Since: 2.4</i>
iconThemeHasIcon :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> m Bool

-- | Gets the list of contexts available within the current hierarchy of
--   icon themes. See <a>iconThemeListIcons</a> for details about contexts.
--   
--   <i>Since: 2.12</i>
iconThemeListContexts :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> m [Text]

-- | Lists the icons in the current icon theme. Only a subset of the icons
--   can be listed by providing a context string. The set of values for the
--   context string is system dependent, but will typically include such
--   values as “Applications” and “MimeTypes”. Contexts are explained in
--   the <a>Icon Theme Specification</a>. The standard contexts are listed
--   in the <a>Icon Naming Specification</a>. Also see
--   <a>iconThemeListContexts</a>.
--   
--   <i>Since: 2.4</i>
iconThemeListIcons :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Maybe Text -> m [Text]

-- | Looks up an icon in an icon theme, scales it to the given size and
--   renders it into a pixbuf. This is a convenience function; if more
--   details about the icon are needed, use <a>iconThemeLookupIcon</a>
--   followed by <a>iconInfoLoadIcon</a>.
--   
--   Note that you probably want to listen for icon theme changes and
--   update the icon. This is usually done by connecting to the
--   GtkWidget<a>styleSet</a> signal. If for some reason you do not want to
--   update the icon when the icon theme changes, you should consider using
--   <a>pixbufCopy</a> to make a private copy of the pixbuf returned by
--   this function. Otherwise GTK+ may need to keep the old icon theme
--   loaded, which would be a waste of memory.
--   
--   <i>Since: 2.4</i>
iconThemeLoadIcon :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> Int32 -> [IconLookupFlags] -> m (Maybe Pixbuf)

-- | Looks up an icon in an icon theme for a particular window scale,
--   scales it to the given size and renders it into a pixbuf. This is a
--   convenience function; if more details about the icon are needed, use
--   <a>iconThemeLookupIcon</a> followed by <a>iconInfoLoadIcon</a>.
--   
--   Note that you probably want to listen for icon theme changes and
--   update the icon. This is usually done by connecting to the
--   GtkWidget<a>styleSet</a> signal. If for some reason you do not want to
--   update the icon when the icon theme changes, you should consider using
--   <a>pixbufCopy</a> to make a private copy of the pixbuf returned by
--   this function. Otherwise GTK+ may need to keep the old icon theme
--   loaded, which would be a waste of memory.
--   
--   <i>Since: 3.10</i>
iconThemeLoadIconForScale :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> Int32 -> Int32 -> [IconLookupFlags] -> m (Maybe Pixbuf)

-- | Looks up an icon in an icon theme for a particular window scale,
--   scales it to the given size and renders it into a cairo surface. This
--   is a convenience function; if more details about the icon are needed,
--   use <a>iconThemeLookupIcon</a> followed by <a>iconInfoLoadSurface</a>.
--   
--   Note that you probably want to listen for icon theme changes and
--   update the icon. This is usually done by connecting to the
--   GtkWidget<a>styleSet</a> signal.
--   
--   <i>Since: 3.10</i>
iconThemeLoadSurface :: (HasCallStack, MonadIO m, IsIconTheme a, IsWindow b) => a -> Text -> Int32 -> Int32 -> Maybe b -> [IconLookupFlags] -> m (Maybe Surface)

-- | Looks up an icon and returns a <a>IconInfo</a> containing information
--   such as the filename of the icon. The icon can then be rendered into a
--   pixbuf using <a>iconInfoLoadIcon</a>.
--   
--   When rendering on displays with high pixel densities you should not
--   use a <i><tt>size</tt></i> multiplied by the scaling factor returned
--   by functions like <a>windowGetScaleFactor</a>. Instead, you should use
--   <a>iconThemeLookupByGiconForScale</a>, as the assets loaded for a
--   given scaling factor may be different.
--   
--   <i>Since: 2.14</i>
iconThemeLookupByGicon :: (HasCallStack, MonadIO m, IsIconTheme a, IsIcon b) => a -> b -> Int32 -> [IconLookupFlags] -> m (Maybe IconInfo)

-- | Looks up an icon and returns a <a>IconInfo</a> containing information
--   such as the filename of the icon. The icon can then be rendered into a
--   pixbuf using <a>iconInfoLoadIcon</a>.
--   
--   <i>Since: 3.10</i>
iconThemeLookupByGiconForScale :: (HasCallStack, MonadIO m, IsIconTheme a, IsIcon b) => a -> b -> Int32 -> Int32 -> [IconLookupFlags] -> m (Maybe IconInfo)

-- | Looks up a named icon for a particular window scale and returns a
--   <a>IconInfo</a> containing information such as the filename of the
--   icon. The icon can then be rendered into a pixbuf using
--   <a>iconInfoLoadIcon</a>. (<a>iconThemeLoadIcon</a> combines these two
--   steps if all you need is the pixbuf.)
--   
--   <i>Since: 3.10</i>
iconThemeLookupIconForScale :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> Int32 -> Int32 -> [IconLookupFlags] -> m (Maybe IconInfo)

-- | Prepends a directory to the search path. See
--   <a>iconThemeSetSearchPath</a>.
--   
--   <i>Since: 2.4</i>
iconThemePrependSearchPath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> [Char] -> m ()

-- | Checks to see if the icon theme has changed; if it has, any currently
--   cached information is discarded and will be reloaded next time
--   <i><tt>iconTheme</tt></i> is accessed.
--   
--   <i>Since: 2.4</i>
iconThemeRescanIfNeeded :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> m Bool

-- | Sets the name of the icon theme that the <a>IconTheme</a> object uses
--   overriding system configuration. This function cannot be called on the
--   icon theme objects returned from <a>iconThemeGetDefault</a> and
--   <a>iconThemeGetForScreen</a>.
--   
--   <i>Since: 2.4</i>
iconThemeSetCustomTheme :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Maybe Text -> m ()

-- | Sets the screen for an icon theme; the screen is used to track the
--   user’s currently configured icon theme, which might be different for
--   different screens.
--   
--   <i>Since: 2.4</i>
iconThemeSetScreen :: (HasCallStack, MonadIO m, IsIconTheme a, IsScreen b) => a -> b -> m ()

-- | Sets the search path for the icon theme object. When looking for an
--   icon theme, GTK+ will search for a subdirectory of one or more of the
--   directories in <i><tt>path</tt></i> with the same name as the icon
--   theme containing an index.theme file. (Themes from multiple of the
--   path elements are combined to allow themes to be extended by adding
--   icons in the user’s home directory.)
--   
--   In addition if an icon found isn’t found either in the current icon
--   theme or the default icon theme, and an image file with the right name
--   is found directly in one of the elements of <i><tt>path</tt></i>, then
--   that image will be used for the icon name. (This is legacy feature,
--   and new icons should be put into the fallback icon theme, which is
--   called hicolor, rather than directly on the icon path.)
--   
--   <i>Since: 2.4</i>
iconThemeSetSearchPath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> [[Char]] -> m ()

-- | Registers a built-in icon for icon theme lookups. The idea of built-in
--   icons is to allow an application or library that uses themed icons to
--   function requiring files to be present in the file system. For
--   instance, the default images for all of GTK+’s stock icons are
--   registered as built-icons.
--   
--   In general, if you use <a>iconThemeAddBuiltinIcon</a> you should also
--   install the icon in the icon theme, so that the icon is generally
--   available.
--   
--   This function will generally be used with pixbufs loaded via
--   <a>pixbufNewFromInline</a>.
--   
--   <i>Since: 2.4</i>
iconThemeAddBuiltinIcon :: (HasCallStack, MonadIO m, IsPixbuf a) => Text -> Int32 -> a -> m ()

-- | Gets the icon theme for the default screen. See
--   <a>iconThemeGetForScreen</a>.
--   
--   <i>Since: 2.4</i>
iconThemeGetDefault :: (HasCallStack, MonadIO m) => m IconTheme

-- | Gets the icon theme object associated with <i><tt>screen</tt></i>; if
--   this function has not previously been called for the given screen, a
--   new icon theme object will be created and associated with the screen.
--   Icon theme objects are fairly expensive to create, so using this
--   function is usually a better choice than calling than
--   <a>iconThemeNew</a> and setting the screen yourself; by using this
--   function a single icon theme object will be shared between users.
--   
--   <i>Since: 2.4</i>
iconThemeGetForScreen :: (HasCallStack, MonadIO m, IsScreen a) => a -> m IconTheme

-- | Cast to <a>HeaderBar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toHeaderBar :: (MonadIO m, IsHeaderBar o) => o -> m HeaderBar

-- | Get the value of the “<tt>custom-title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> headerBar #customTitle
--   </pre>
getHeaderBarCustomTitle :: (MonadIO m, IsHeaderBar o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>custom-title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> headerBar [ #customTitle <a>:=</a> value ]
--   </pre>
setHeaderBarCustomTitle :: (MonadIO m, IsHeaderBar o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>custom-title</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructHeaderBarCustomTitle :: (IsHeaderBar o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>custom-title</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #customTitle
--   </pre>
clearHeaderBarCustomTitle :: (MonadIO m, IsHeaderBar o) => o -> m ()

-- | Get the value of the “<tt>decoration-layout</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> headerBar #decorationLayout
--   </pre>
getHeaderBarDecorationLayout :: (MonadIO m, IsHeaderBar o) => o -> m Text

-- | Set the value of the “<tt>decoration-layout</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> headerBar [ #decorationLayout <a>:=</a> value ]
--   </pre>
setHeaderBarDecorationLayout :: (MonadIO m, IsHeaderBar o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>decoration-layout</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructHeaderBarDecorationLayout :: (IsHeaderBar o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>decoration-layout</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #decorationLayout
--   </pre>
clearHeaderBarDecorationLayout :: (MonadIO m, IsHeaderBar o) => o -> m ()

-- | Get the value of the “<tt>decoration-layout-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> headerBar #decorationLayoutSet
--   </pre>
getHeaderBarDecorationLayoutSet :: (MonadIO m, IsHeaderBar o) => o -> m Bool

-- | Set the value of the “<tt>decoration-layout-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> headerBar [ #decorationLayoutSet <a>:=</a> value ]
--   </pre>
setHeaderBarDecorationLayoutSet :: (MonadIO m, IsHeaderBar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>decoration-layout-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructHeaderBarDecorationLayoutSet :: (IsHeaderBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-subtitle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> headerBar #hasSubtitle
--   </pre>
getHeaderBarHasSubtitle :: (MonadIO m, IsHeaderBar o) => o -> m Bool

-- | Set the value of the “<tt>has-subtitle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> headerBar [ #hasSubtitle <a>:=</a> value ]
--   </pre>
setHeaderBarHasSubtitle :: (MonadIO m, IsHeaderBar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-subtitle</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructHeaderBarHasSubtitle :: (IsHeaderBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-close-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> headerBar #showCloseButton
--   </pre>
getHeaderBarShowCloseButton :: (MonadIO m, IsHeaderBar o) => o -> m Bool

-- | Set the value of the “<tt>show-close-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> headerBar [ #showCloseButton <a>:=</a> value ]
--   </pre>
setHeaderBarShowCloseButton :: (MonadIO m, IsHeaderBar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-close-button</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructHeaderBarShowCloseButton :: (IsHeaderBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> headerBar #spacing
--   </pre>
getHeaderBarSpacing :: (MonadIO m, IsHeaderBar o) => o -> m Int32

-- | Set the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> headerBar [ #spacing <a>:=</a> value ]
--   </pre>
setHeaderBarSpacing :: (MonadIO m, IsHeaderBar o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>spacing</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructHeaderBarSpacing :: (IsHeaderBar o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>subtitle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> headerBar #subtitle
--   </pre>
getHeaderBarSubtitle :: (MonadIO m, IsHeaderBar o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>subtitle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> headerBar [ #subtitle <a>:=</a> value ]
--   </pre>
setHeaderBarSubtitle :: (MonadIO m, IsHeaderBar o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>subtitle</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructHeaderBarSubtitle :: (IsHeaderBar o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>subtitle</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #subtitle
--   </pre>
clearHeaderBarSubtitle :: (MonadIO m, IsHeaderBar o) => o -> m ()

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> headerBar #title
--   </pre>
getHeaderBarTitle :: (MonadIO m, IsHeaderBar o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> headerBar [ #title <a>:=</a> value ]
--   </pre>
setHeaderBarTitle :: (MonadIO m, IsHeaderBar o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructHeaderBarTitle :: (IsHeaderBar o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>title</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #title
--   </pre>
clearHeaderBarTitle :: (MonadIO m, IsHeaderBar o) => o -> m ()

-- | Creates a new <a>HeaderBar</a> widget.
--   
--   <i>Since: 3.10</i>
headerBarNew :: (HasCallStack, MonadIO m) => m HeaderBar

-- | Retrieves the custom title widget of the header. See
--   <a>headerBarSetCustomTitle</a>.
--   
--   <i>Since: 3.10</i>
headerBarGetCustomTitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> m (Maybe Widget)

-- | Gets the decoration layout set with
--   <a>headerBarSetDecorationLayout</a>.
--   
--   <i>Since: 3.12</i>
headerBarGetDecorationLayout :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> m Text

-- | Retrieves whether the header bar reserves space for a subtitle,
--   regardless if one is currently set or not.
--   
--   <i>Since: 3.12</i>
headerBarGetHasSubtitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> m Bool

-- | Returns whether this header bar shows the standard window decorations.
--   
--   <i>Since: 3.10</i>
headerBarGetShowCloseButton :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> m Bool

-- | Retrieves the subtitle of the header. See <a>headerBarSetSubtitle</a>.
--   
--   <i>Since: 3.10</i>
headerBarGetSubtitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> m (Maybe Text)

-- | Retrieves the title of the header. See <a>headerBarSetTitle</a>.
--   
--   <i>Since: 3.10</i>
headerBarGetTitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> m (Maybe Text)

-- | Adds <i><tt>child</tt></i> to <i><tt>bar</tt></i>, packed with
--   reference to the end of the <i><tt>bar</tt></i>.
--   
--   <i>Since: 3.10</i>
headerBarPackEnd :: (HasCallStack, MonadIO m, IsHeaderBar a, IsWidget b) => a -> b -> m ()

-- | Adds <i><tt>child</tt></i> to <i><tt>bar</tt></i>, packed with
--   reference to the start of the <i><tt>bar</tt></i>.
--   
--   <i>Since: 3.10</i>
headerBarPackStart :: (HasCallStack, MonadIO m, IsHeaderBar a, IsWidget b) => a -> b -> m ()

-- | Sets a custom title for the <a>HeaderBar</a>.
--   
--   The title should help a user identify the current view. This
--   supersedes any title set by <a>headerBarSetTitle</a> or
--   <a>headerBarSetSubtitle</a>. To achieve the same style as the builtin
--   title and subtitle, use the “title” and “subtitle” style classes.
--   
--   You should set the custom title to <a>Nothing</a>, for the header
--   title label to be visible again.
--   
--   <i>Since: 3.10</i>
headerBarSetCustomTitle :: (HasCallStack, MonadIO m, IsHeaderBar a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the decoration layout for this header bar, overriding the
--   <a>Settings:gtkDecorationLayout</a> setting.
--   
--   There can be valid reasons for overriding the setting, such as a
--   header bar design that does not allow for buttons to take room on the
--   right, or only offers room for a single close button. Split header
--   bars are another example for overriding the setting.
--   
--   The format of the string is button names, separated by commas. A colon
--   separates the buttons that should appear on the left from those on the
--   right. Recognized button names are minimize, maximize, close, icon
--   (the window icon) and menu (a menu button for the fallback app menu).
--   
--   For example, “menu:minimize,maximize,close” specifies a menu on the
--   left, and minimize, maximize and close buttons on the right.
--   
--   <i>Since: 3.12</i>
headerBarSetDecorationLayout :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Maybe Text -> m ()

-- | Sets whether the header bar should reserve space for a subtitle, even
--   if none is currently set.
--   
--   <i>Since: 3.12</i>
headerBarSetHasSubtitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Bool -> m ()

-- | Sets whether this header bar shows the standard window decorations,
--   including close, maximize, and minimize.
--   
--   <i>Since: 3.10</i>
headerBarSetShowCloseButton :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Bool -> m ()

-- | Sets the subtitle of the <a>HeaderBar</a>. The title should give a
--   user an additional detail to help him identify the current view.
--   
--   Note that GtkHeaderBar by default reserves room for the subtitle, even
--   if none is currently set. If this is not desired, set the
--   <a>HeaderBar:hasSubtitle</a> property to <a>False</a>.
--   
--   <i>Since: 3.10</i>
headerBarSetSubtitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Maybe Text -> m ()

-- | Sets the title of the <a>HeaderBar</a>. The title should help a user
--   identify the current view. A good title should not include the
--   application name.
--   
--   <i>Since: 3.10</i>
headerBarSetTitle :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Maybe Text -> m ()

-- | Cast to <a>HandleBox</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toHandleBox :: (MonadIO m, IsHandleBox o) => o -> m HandleBox

-- | Connect a signal handler for the <a>childAttached</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> handleBox #childAttached callback
--   </pre>
onHandleBoxChildAttached :: (IsHandleBox a, MonadIO m) => a -> ((?self :: a) => HandleBoxChildAttachedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>childAttached</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> handleBox #childAttached callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterHandleBoxChildAttached :: (IsHandleBox a, MonadIO m) => a -> ((?self :: a) => HandleBoxChildAttachedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>childDetached</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> handleBox #childDetached callback
--   </pre>
onHandleBoxChildDetached :: (IsHandleBox a, MonadIO m) => a -> ((?self :: a) => HandleBoxChildDetachedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>childDetached</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> handleBox #childDetached callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterHandleBoxChildDetached :: (IsHandleBox a, MonadIO m) => a -> ((?self :: a) => HandleBoxChildDetachedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>child-detached</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> handleBox #childDetached
--   </pre>
getHandleBoxChildDetached :: (MonadIO m, IsHandleBox o) => o -> m Bool

-- | Get the value of the “<tt>handle-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> handleBox #handlePosition
--   </pre>
getHandleBoxHandlePosition :: (MonadIO m, IsHandleBox o) => o -> m PositionType

-- | Set the value of the “<tt>handle-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> handleBox [ #handlePosition <a>:=</a> value ]
--   </pre>
setHandleBoxHandlePosition :: (MonadIO m, IsHandleBox o) => o -> PositionType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>handle-position</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructHandleBoxHandlePosition :: (IsHandleBox o, MonadIO m) => PositionType -> m (GValueConstruct o)

-- | Get the value of the “<tt>shadow-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> handleBox #shadowType
--   </pre>
getHandleBoxShadowType :: (MonadIO m, IsHandleBox o) => o -> m ShadowType

-- | Set the value of the “<tt>shadow-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> handleBox [ #shadowType <a>:=</a> value ]
--   </pre>
setHandleBoxShadowType :: (MonadIO m, IsHandleBox o) => o -> ShadowType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>shadow-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructHandleBoxShadowType :: (IsHandleBox o, MonadIO m) => ShadowType -> m (GValueConstruct o)

-- | Get the value of the “<tt>snap-edge</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> handleBox #snapEdge
--   </pre>
getHandleBoxSnapEdge :: (MonadIO m, IsHandleBox o) => o -> m PositionType

-- | Set the value of the “<tt>snap-edge</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> handleBox [ #snapEdge <a>:=</a> value ]
--   </pre>
setHandleBoxSnapEdge :: (MonadIO m, IsHandleBox o) => o -> PositionType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>snap-edge</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructHandleBoxSnapEdge :: (IsHandleBox o, MonadIO m) => PositionType -> m (GValueConstruct o)

-- | Get the value of the “<tt>snap-edge-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> handleBox #snapEdgeSet
--   </pre>
getHandleBoxSnapEdgeSet :: (MonadIO m, IsHandleBox o) => o -> m Bool

-- | Set the value of the “<tt>snap-edge-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> handleBox [ #snapEdgeSet <a>:=</a> value ]
--   </pre>
setHandleBoxSnapEdgeSet :: (MonadIO m, IsHandleBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>snap-edge-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructHandleBoxSnapEdgeSet :: (IsHandleBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Create a new handle box.
handleBoxNew :: (HasCallStack, MonadIO m) => m HandleBox

-- | Whether the handlebox’s child is currently detached.
--   
--   <i>Since: 2.14</i>
handleBoxGetChildDetached :: (HasCallStack, MonadIO m, IsHandleBox a) => a -> m Bool

-- | Gets the handle position of the handle box. See
--   <a>handleBoxSetHandlePosition</a>.
handleBoxGetHandlePosition :: (HasCallStack, MonadIO m, IsHandleBox a) => a -> m PositionType

-- | Gets the type of shadow drawn around the handle box. See
--   <a>handleBoxSetShadowType</a>.
handleBoxGetShadowType :: (HasCallStack, MonadIO m, IsHandleBox a) => a -> m ShadowType

-- | Gets the edge used for determining reattachment of the handle box. See
--   <a>handleBoxSetSnapEdge</a>.
handleBoxGetSnapEdge :: (HasCallStack, MonadIO m, IsHandleBox a) => a -> m PositionType

-- | Sets the side of the handlebox where the handle is drawn.
handleBoxSetHandlePosition :: (HasCallStack, MonadIO m, IsHandleBox a) => a -> PositionType -> m ()

-- | Sets the type of shadow to be drawn around the border of the handle
--   box.
handleBoxSetShadowType :: (HasCallStack, MonadIO m, IsHandleBox a) => a -> ShadowType -> m ()

-- | Sets the snap edge of a handlebox. The snap edge is the edge of the
--   detached child that must be aligned with the corresponding edge of the
--   “ghost” left behind when the child was detached to reattach the
--   torn-off window. Usually, the snap edge should be chosen so that it
--   stays in the same place on the screen when the handlebox is torn off.
--   
--   If the snap edge is not set, then an appropriate value will be guessed
--   from the handle position. If the handle position is
--   <a>PositionTypeRight</a> or <a>PositionTypeLeft</a>, then the snap
--   edge will be <a>PositionTypeTop</a>, otherwise it will be
--   <a>PositionTypeLeft</a>.
handleBoxSetSnapEdge :: (HasCallStack, MonadIO m, IsHandleBox a) => a -> PositionType -> m ()

-- | Cast to <a>HSeparator</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toHSeparator :: (MonadIO m, IsHSeparator o) => o -> m HSeparator

-- | Creates a new <a>HSeparator</a>.
hSeparatorNew :: (HasCallStack, MonadIO m) => m HSeparator

-- | Cast to <a>HScrollbar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toHScrollbar :: (MonadIO m, IsHScrollbar o) => o -> m HScrollbar

-- | Creates a new horizontal scrollbar.
hScrollbarNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe a -> m HScrollbar

-- | Cast to <a>HScale</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toHScale :: (MonadIO m, IsHScale o) => o -> m HScale

-- | Creates a new <a>HScale</a>.
hScaleNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe a -> m HScale

-- | Creates a new horizontal scale widget that lets the user input a
--   number between <i><tt>min</tt></i> and <i><tt>max</tt></i> (including
--   <i><tt>min</tt></i> and <i><tt>max</tt></i>) with the increment
--   <i><tt>step</tt></i>. <i><tt>step</tt></i> must be nonzero; it’s the
--   distance the slider moves when using the arrow keys to adjust the
--   scale value.
--   
--   Note that the way in which the precision is derived works best if
--   <i><tt>step</tt></i> is a power of ten. If the resulting precision is
--   not suitable for your needs, use <a>scaleSetDigits</a> to correct it.
hScaleNewWithRange :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> m HScale

-- | Cast to <a>HSV</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toHSV :: (MonadIO m, IsHSV o) => o -> m HSV

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> hSV #changed callback
--   </pre>
onHSVChanged :: (IsHSV a, MonadIO m) => a -> ((?self :: a) => HSVChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> hSV #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterHSVChanged :: (IsHSV a, MonadIO m) => a -> ((?self :: a) => HSVChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>move</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> hSV #move callback
--   </pre>
onHSVMove :: (IsHSV a, MonadIO m) => a -> ((?self :: a) => HSVMoveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>move</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> hSV #move callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterHSVMove :: (IsHSV a, MonadIO m) => a -> ((?self :: a) => HSVMoveCallback) -> m SignalHandlerId

-- | Creates a new HSV color selector.
--   
--   <i>Since: 2.14</i>
hSVNew :: (HasCallStack, MonadIO m) => m HSV

-- | Queries the current color in an HSV color selector. Returned values
--   will be in the [0.0, 1.0] range.
--   
--   <i>Since: 2.14</i>
hSVGetColor :: (HasCallStack, MonadIO m, IsHSV a) => a -> m (Double, Double, Double)

-- | Queries the size and ring width of an HSV color selector.
--   
--   <i>Since: 2.14</i>
hSVGetMetrics :: (HasCallStack, MonadIO m, IsHSV a) => a -> m (Int32, Int32)

-- | An HSV color selector can be said to be adjusting if multiple rapid
--   changes are being made to its value, for example, when the user is
--   adjusting the value with the mouse. This function queries whether the
--   HSV color selector is being adjusted or not.
--   
--   <i>Since: 2.14</i>
hSVIsAdjusting :: (HasCallStack, MonadIO m, IsHSV a) => a -> m Bool

-- | Sets the current color in an HSV color selector. Color component
--   values must be in the [0.0, 1.0] range.
--   
--   <i>Since: 2.14</i>
hSVSetColor :: (HasCallStack, MonadIO m, IsHSV a) => a -> Double -> Double -> Double -> m ()

-- | Sets the size and ring width of an HSV color selector.
--   
--   <i>Since: 2.14</i>
hSVSetMetrics :: (HasCallStack, MonadIO m, IsHSV a) => a -> Int32 -> Int32 -> m ()

-- | Converts a color from HSV space to RGB.
--   
--   Input values must be in the [0.0, 1.0] range; output values will be in
--   the same range.
--   
--   <i>Since: 2.14</i>
hSVToRgb :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> m (Double, Double, Double)

-- | Cast to <a>HPaned</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toHPaned :: (MonadIO m, IsHPaned o) => o -> m HPaned

-- | Create a new <a>HPaned</a>
hPanedNew :: (HasCallStack, MonadIO m) => m HPaned

-- | Cast to <a>Grid</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toGrid :: (MonadIO m, IsGrid o) => o -> m Grid

-- | Get the value of the “<tt>baseline-row</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> grid #baselineRow
--   </pre>
getGridBaselineRow :: (MonadIO m, IsGrid o) => o -> m Int32

-- | Set the value of the “<tt>baseline-row</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> grid [ #baselineRow <a>:=</a> value ]
--   </pre>
setGridBaselineRow :: (MonadIO m, IsGrid o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>baseline-row</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGridBaselineRow :: (IsGrid o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>column-homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> grid #columnHomogeneous
--   </pre>
getGridColumnHomogeneous :: (MonadIO m, IsGrid o) => o -> m Bool

-- | Set the value of the “<tt>column-homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> grid [ #columnHomogeneous <a>:=</a> value ]
--   </pre>
setGridColumnHomogeneous :: (MonadIO m, IsGrid o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>column-homogeneous</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructGridColumnHomogeneous :: (IsGrid o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>column-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> grid #columnSpacing
--   </pre>
getGridColumnSpacing :: (MonadIO m, IsGrid o) => o -> m Int32

-- | Set the value of the “<tt>column-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> grid [ #columnSpacing <a>:=</a> value ]
--   </pre>
setGridColumnSpacing :: (MonadIO m, IsGrid o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>column-spacing</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructGridColumnSpacing :: (IsGrid o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>row-homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> grid #rowHomogeneous
--   </pre>
getGridRowHomogeneous :: (MonadIO m, IsGrid o) => o -> m Bool

-- | Set the value of the “<tt>row-homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> grid [ #rowHomogeneous <a>:=</a> value ]
--   </pre>
setGridRowHomogeneous :: (MonadIO m, IsGrid o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>row-homogeneous</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructGridRowHomogeneous :: (IsGrid o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>row-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> grid #rowSpacing
--   </pre>
getGridRowSpacing :: (MonadIO m, IsGrid o) => o -> m Int32

-- | Set the value of the “<tt>row-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> grid [ #rowSpacing <a>:=</a> value ]
--   </pre>
setGridRowSpacing :: (MonadIO m, IsGrid o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>row-spacing</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGridRowSpacing :: (IsGrid o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new grid widget.
gridNew :: (HasCallStack, MonadIO m) => m Grid

-- | Adds a widget to the grid.
--   
--   The widget is placed next to <i><tt>sibling</tt></i>, on the side
--   determined by <i><tt>side</tt></i>. When <i><tt>sibling</tt></i> is
--   <a>Nothing</a>, the widget is placed in row (for left or right
--   placement) or column 0 (for top or bottom placement), at the end
--   indicated by <i><tt>side</tt></i>.
--   
--   Attaching widgets labeled [1], [2], [3] with <i><tt>sibling</tt></i>
--   == <a>Nothing</a> and <i><tt>side</tt></i> == <a>PositionTypeLeft</a>
--   yields a layout of [3][2][1].
gridAttachNextTo :: (HasCallStack, MonadIO m, IsGrid a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> PositionType -> Int32 -> Int32 -> m ()

-- | Returns which row defines the global baseline of <i><tt>grid</tt></i>.
--   
--   <i>Since: 3.10</i>
gridGetBaselineRow :: (HasCallStack, MonadIO m, IsGrid a) => a -> m Int32

-- | Gets the child of <i><tt>grid</tt></i> whose area covers the grid cell
--   whose upper left corner is at <i><tt>left</tt></i>,
--   <i><tt>top</tt></i>.
--   
--   <i>Since: 3.2</i>
gridGetChildAt :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> Int32 -> m (Maybe Widget)

-- | Returns whether all columns of <i><tt>grid</tt></i> have the same
--   width.
gridGetColumnHomogeneous :: (HasCallStack, MonadIO m, IsGrid a) => a -> m Bool

-- | Returns the amount of space between the columns of
--   <i><tt>grid</tt></i>.
gridGetColumnSpacing :: (HasCallStack, MonadIO m, IsGrid a) => a -> m Word32

-- | Returns the baseline position of <i><tt>row</tt></i> as set by
--   <a>gridSetRowBaselinePosition</a> or the default value
--   <a>BaselinePositionCenter</a>.
--   
--   <i>Since: 3.10</i>
gridGetRowBaselinePosition :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> m BaselinePosition

-- | Returns whether all rows of <i><tt>grid</tt></i> have the same height.
gridGetRowHomogeneous :: (HasCallStack, MonadIO m, IsGrid a) => a -> m Bool

-- | Returns the amount of space between the rows of <i><tt>grid</tt></i>.
gridGetRowSpacing :: (HasCallStack, MonadIO m, IsGrid a) => a -> m Word32

-- | Inserts a column at the specified position.
--   
--   Children which are attached at or to the right of this position are
--   moved one column to the right. Children which span across this
--   position are grown to span the new column.
--   
--   <i>Since: 3.2</i>
gridInsertColumn :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> m ()

-- | Inserts a row or column at the specified position.
--   
--   The new row or column is placed next to <i><tt>sibling</tt></i>, on
--   the side determined by <i><tt>side</tt></i>. If <i><tt>side</tt></i>
--   is <a>PositionTypeTop</a> or <a>PositionTypeBottom</a>, a row is
--   inserted. If <i><tt>side</tt></i> is <a>PositionTypeLeft</a> of
--   <a>PositionTypeRight</a>, a column is inserted.
--   
--   <i>Since: 3.2</i>
gridInsertNextTo :: (HasCallStack, MonadIO m, IsGrid a, IsWidget b) => a -> b -> PositionType -> m ()

-- | Inserts a row at the specified position.
--   
--   Children which are attached at or below this position are moved one
--   row down. Children which span across this position are grown to span
--   the new row.
--   
--   <i>Since: 3.2</i>
gridInsertRow :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> m ()

-- | Removes a column from the grid.
--   
--   Children that are placed in this column are removed, spanning children
--   that overlap this column have their width reduced by one, and children
--   after the column are moved to the left.
--   
--   <i>Since: 3.10</i>
gridRemoveColumn :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> m ()

-- | Removes a row from the grid.
--   
--   Children that are placed in this row are removed, spanning children
--   that overlap this row have their height reduced by one, and children
--   below the row are moved up.
--   
--   <i>Since: 3.10</i>
gridRemoveRow :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> m ()

-- | Sets which row defines the global baseline for the entire grid. Each
--   row in the grid can have its own local baseline, but only one of those
--   is global, meaning it will be the baseline in the parent of the
--   <i><tt>grid</tt></i>.
--   
--   <i>Since: 3.10</i>
gridSetBaselineRow :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> m ()

-- | Sets whether all columns of <i><tt>grid</tt></i> will have the same
--   width.
gridSetColumnHomogeneous :: (HasCallStack, MonadIO m, IsGrid a) => a -> Bool -> m ()

-- | Sets the amount of space between columns of <i><tt>grid</tt></i>.
gridSetColumnSpacing :: (HasCallStack, MonadIO m, IsGrid a) => a -> Word32 -> m ()

-- | Sets how the baseline should be positioned on <i><tt>row</tt></i> of
--   the grid, in case that row is assigned more space than is requested.
--   
--   <i>Since: 3.10</i>
gridSetRowBaselinePosition :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> BaselinePosition -> m ()

-- | Sets whether all rows of <i><tt>grid</tt></i> will have the same
--   height.
gridSetRowHomogeneous :: (HasCallStack, MonadIO m, IsGrid a) => a -> Bool -> m ()

-- | Sets the amount of space between rows of <i><tt>grid</tt></i>.
gridSetRowSpacing :: (HasCallStack, MonadIO m, IsGrid a) => a -> Word32 -> m ()

-- | Cast to <a>GLArea</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toGLArea :: (MonadIO m, IsGLArea o) => o -> m GLArea

-- | Connect a signal handler for the <a>createContext</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> gLArea #createContext callback
--   </pre>
onGLAreaCreateContext :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaCreateContextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>createContext</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> gLArea #createContext callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGLAreaCreateContext :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaCreateContextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>render</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gLArea #render callback
--   </pre>
onGLAreaRender :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaRenderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>render</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gLArea #render callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGLAreaRender :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaRenderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>resize</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gLArea #resize callback
--   </pre>
onGLAreaResize :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaResizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>resize</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gLArea #resize callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGLAreaResize :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaResizeCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>auto-render</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gLArea #autoRender
--   </pre>
getGLAreaAutoRender :: (MonadIO m, IsGLArea o) => o -> m Bool

-- | Set the value of the “<tt>auto-render</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gLArea [ #autoRender <a>:=</a> value ]
--   </pre>
setGLAreaAutoRender :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>auto-render</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGLAreaAutoRender :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>context</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gLArea #context
--   </pre>
getGLAreaContext :: (MonadIO m, IsGLArea o) => o -> m GLContext

-- | Get the value of the “<tt>has-alpha</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gLArea #hasAlpha
--   </pre>
getGLAreaHasAlpha :: (MonadIO m, IsGLArea o) => o -> m Bool

-- | Set the value of the “<tt>has-alpha</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gLArea [ #hasAlpha <a>:=</a> value ]
--   </pre>
setGLAreaHasAlpha :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-alpha</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructGLAreaHasAlpha :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-depth-buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gLArea #hasDepthBuffer
--   </pre>
getGLAreaHasDepthBuffer :: (MonadIO m, IsGLArea o) => o -> m Bool

-- | Set the value of the “<tt>has-depth-buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gLArea [ #hasDepthBuffer <a>:=</a> value ]
--   </pre>
setGLAreaHasDepthBuffer :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-depth-buffer</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructGLAreaHasDepthBuffer :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-stencil-buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gLArea #hasStencilBuffer
--   </pre>
getGLAreaHasStencilBuffer :: (MonadIO m, IsGLArea o) => o -> m Bool

-- | Set the value of the “<tt>has-stencil-buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gLArea [ #hasStencilBuffer <a>:=</a> value ]
--   </pre>
setGLAreaHasStencilBuffer :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-stencil-buffer</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructGLAreaHasStencilBuffer :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-es</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gLArea #useEs
--   </pre>
getGLAreaUseEs :: (MonadIO m, IsGLArea o) => o -> m Bool

-- | Set the value of the “<tt>use-es</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gLArea [ #useEs <a>:=</a> value ]
--   </pre>
setGLAreaUseEs :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-es</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructGLAreaUseEs :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>GLArea</a> widget.
--   
--   <i>Since: 3.16</i>
gLAreaNew :: (HasCallStack, MonadIO m) => m GLArea

-- | Ensures that the <i><tt>area</tt></i> framebuffer object is made the
--   current draw and read target, and that all the required buffers for
--   the <i><tt>area</tt></i> are created and bound to the frambuffer.
--   
--   This function is automatically called before emitting the
--   <a>GLArea::render</a> signal, and doesn't normally need to be called
--   by application code.
--   
--   <i>Since: 3.16</i>
gLAreaAttachBuffers :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m ()

-- | Returns whether the area is in auto render mode or not.
--   
--   <i>Since: 3.16</i>
gLAreaGetAutoRender :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool

-- | Retrieves the <a>GLContext</a> used by <i><tt>area</tt></i>.
--   
--   <i>Since: 3.16</i>
gLAreaGetContext :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m GLContext

-- | Gets the current error set on the <i><tt>area</tt></i>.
--   
--   <i>Since: 3.16</i>
gLAreaGetError :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m (Maybe GError)

-- | Returns whether the area has an alpha component.
--   
--   <i>Since: 3.16</i>
gLAreaGetHasAlpha :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool

-- | Returns whether the area has a depth buffer.
--   
--   <i>Since: 3.16</i>
gLAreaGetHasDepthBuffer :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool

-- | Returns whether the area has a stencil buffer.
--   
--   <i>Since: 3.16</i>
gLAreaGetHasStencilBuffer :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool

-- | Retrieves the required version of OpenGL set using
--   <a>gLAreaSetRequiredVersion</a>.
--   
--   <i>Since: 3.16</i>
gLAreaGetRequiredVersion :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m (Int32, Int32)

-- | Retrieves the value set by <a>gLAreaSetUseEs</a>.
--   
--   <i>Since: 3.22</i>
gLAreaGetUseEs :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool

-- | Ensures that the <a>GLContext</a> used by <i><tt>area</tt></i> is
--   associated with the <a>GLArea</a>.
--   
--   This function is automatically called before emitting the
--   <a>GLArea::render</a> signal, and doesn't normally need to be called
--   by application code.
--   
--   <i>Since: 3.16</i>
gLAreaMakeCurrent :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m ()

-- | Marks the currently rendered data (if any) as invalid, and queues a
--   redraw of the widget, ensuring that the <a>GLArea::render</a> signal
--   is emitted during the draw.
--   
--   This is only needed when the <a>gLAreaSetAutoRender</a> has been
--   called with a <a>False</a> value. The default behaviour is to emit
--   <a>GLArea::render</a> on each draw.
--   
--   <i>Since: 3.16</i>
gLAreaQueueRender :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m ()

-- | If <i><tt>autoRender</tt></i> is <a>True</a> the <a>GLArea::render</a>
--   signal will be emitted every time the widget draws. This is the
--   default and is useful if drawing the widget is faster.
--   
--   If <i><tt>autoRender</tt></i> is <a>False</a> the data from previous
--   rendering is kept around and will be used for drawing the widget the
--   next time, unless the window is resized. In order to force a rendering
--   <a>gLAreaQueueRender</a> must be called. This mode is useful when the
--   scene changes seldomly, but takes a long time to redraw.
--   
--   <i>Since: 3.16</i>
gLAreaSetAutoRender :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()

-- | Sets an error on the area which will be shown instead of the GL
--   rendering. This is useful in the <a>GLArea::createContext</a> signal
--   if GL context creation fails.
--   
--   <i>Since: 3.16</i>
gLAreaSetError :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Maybe GError -> m ()

-- | If <i><tt>hasAlpha</tt></i> is <a>True</a> the buffer allocated by the
--   widget will have an alpha channel component, and when rendering to the
--   window the result will be composited over whatever is below the
--   widget.
--   
--   If <i><tt>hasAlpha</tt></i> is <a>False</a> there will be no alpha
--   channel, and the buffer will fully replace anything below the widget.
--   
--   <i>Since: 3.16</i>
gLAreaSetHasAlpha :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()

-- | If <i><tt>hasDepthBuffer</tt></i> is <a>True</a> the widget will
--   allocate and enable a depth buffer for the target framebuffer.
--   Otherwise there will be none.
--   
--   <i>Since: 3.16</i>
gLAreaSetHasDepthBuffer :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()

-- | If <i><tt>hasStencilBuffer</tt></i> is <a>True</a> the widget will
--   allocate and enable a stencil buffer for the target framebuffer.
--   Otherwise there will be none.
--   
--   <i>Since: 3.16</i>
gLAreaSetHasStencilBuffer :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()

-- | Sets the required version of OpenGL to be used when creating the
--   context for the widget.
--   
--   This function must be called before the area has been realized.
--   
--   <i>Since: 3.16</i>
gLAreaSetRequiredVersion :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Int32 -> Int32 -> m ()

-- | Sets whether the <i><tt>area</tt></i> should create an OpenGL or an
--   OpenGL ES context.
--   
--   You should check the capabilities of the <a>GLContext</a> before
--   drawing with either API.
--   
--   <i>Since: 3.22</i>
gLAreaSetUseEs :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()

-- | Cast to <a>Frame</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toFrame :: (MonadIO m, IsFrame o) => o -> m Frame

-- | Get the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> frame #label
--   </pre>
getFrameLabel :: (MonadIO m, IsFrame o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> frame [ #label <a>:=</a> value ]
--   </pre>
setFrameLabel :: (MonadIO m, IsFrame o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFrameLabel :: (IsFrame o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>label</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #label
--   </pre>
clearFrameLabel :: (MonadIO m, IsFrame o) => o -> m ()

-- | Get the value of the “<tt>label-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> frame #labelWidget
--   </pre>
getFrameLabelWidget :: (MonadIO m, IsFrame o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>label-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> frame [ #labelWidget <a>:=</a> value ]
--   </pre>
setFrameLabelWidget :: (MonadIO m, IsFrame o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label-widget</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFrameLabelWidget :: (IsFrame o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>label-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #labelWidget
--   </pre>
clearFrameLabelWidget :: (MonadIO m, IsFrame o) => o -> m ()

-- | Get the value of the “<tt>label-xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> frame #labelXalign
--   </pre>
getFrameLabelXalign :: (MonadIO m, IsFrame o) => o -> m Float

-- | Set the value of the “<tt>label-xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> frame [ #labelXalign <a>:=</a> value ]
--   </pre>
setFrameLabelXalign :: (MonadIO m, IsFrame o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label-xalign</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFrameLabelXalign :: (IsFrame o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>label-yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> frame #labelYalign
--   </pre>
getFrameLabelYalign :: (MonadIO m, IsFrame o) => o -> m Float

-- | Set the value of the “<tt>label-yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> frame [ #labelYalign <a>:=</a> value ]
--   </pre>
setFrameLabelYalign :: (MonadIO m, IsFrame o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label-yalign</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFrameLabelYalign :: (IsFrame o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>shadow-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> frame #shadowType
--   </pre>
getFrameShadowType :: (MonadIO m, IsFrame o) => o -> m ShadowType

-- | Set the value of the “<tt>shadow-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> frame [ #shadowType <a>:=</a> value ]
--   </pre>
setFrameShadowType :: (MonadIO m, IsFrame o) => o -> ShadowType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>shadow-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFrameShadowType :: (IsFrame o, MonadIO m) => ShadowType -> m (GValueConstruct o)

-- | Creates a new <a>Frame</a>, with optional label <i><tt>label</tt></i>.
--   If <i><tt>label</tt></i> is <a>Nothing</a>, the label is omitted.
frameNew :: (HasCallStack, MonadIO m) => Maybe Text -> m Frame

-- | If the frame’s label widget is a <a>Label</a>, returns the text in the
--   label widget. (The frame will have a <a>Label</a> for the label widget
--   if a non-<a>Nothing</a> argument was passed to <a>frameNew</a>.)
frameGetLabel :: (HasCallStack, MonadIO m, IsFrame a) => a -> m (Maybe Text)

-- | Retrieves the X and Y alignment of the frame’s label. See
--   <a>frameSetLabelAlign</a>.
frameGetLabelAlign :: (HasCallStack, MonadIO m, IsFrame a) => a -> m (Float, Float)

-- | Retrieves the label widget for the frame. See
--   <a>frameSetLabelWidget</a>.
frameGetLabelWidget :: (HasCallStack, MonadIO m, IsFrame a) => a -> m (Maybe Widget)

-- | Retrieves the shadow type of the frame. See <a>frameSetShadowType</a>.
frameGetShadowType :: (HasCallStack, MonadIO m, IsFrame a) => a -> m ShadowType

-- | Removes the current <a>Frame:labelWidget</a>. If <i><tt>label</tt></i>
--   is not <a>Nothing</a>, creates a new <a>Label</a> with that text and
--   adds it as the <a>Frame:labelWidget</a>.
frameSetLabel :: (HasCallStack, MonadIO m, IsFrame a) => a -> Maybe Text -> m ()

-- | Sets the alignment of the frame widget’s label. The default values for
--   a newly created frame are 0.0 and 0.5.
frameSetLabelAlign :: (HasCallStack, MonadIO m, IsFrame a) => a -> Float -> Float -> m ()

-- | Sets the <a>Frame:labelWidget</a> for the frame. This is the widget
--   that will appear embedded in the top edge of the frame as a title.
frameSetLabelWidget :: (HasCallStack, MonadIO m, IsFrame a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the <a>Frame:shadowType</a> for <i><tt>frame</tt></i>, i.e.
--   whether it is drawn without (<a>ShadowTypeNone</a>) or with (other
--   values) a visible border. Values other than <a>ShadowTypeNone</a> are
--   treated identically by GtkFrame. The chosen type is applied by
--   removing or adding the .flat class to the CSS node named border.
frameSetShadowType :: (HasCallStack, MonadIO m, IsFrame a) => a -> ShadowType -> m ()

-- | Cast to <a>Fixed</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toFixed :: (MonadIO m, IsFixed o) => o -> m Fixed

-- | Creates a new <a>Fixed</a>.
fixedNew :: (HasCallStack, MonadIO m) => m Fixed

-- | Moves a child of a <a>Fixed</a> container to the given position.
fixedMove :: (HasCallStack, MonadIO m, IsFixed a, IsWidget b) => a -> b -> Int32 -> Int32 -> m ()

-- | Adds a widget to a <a>Fixed</a> container at the given position.
fixedPut :: (HasCallStack, MonadIO m, IsFixed a, IsWidget b) => a -> b -> Int32 -> Int32 -> m ()

-- | Cast to <a>FileFilter</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFileFilter :: (MonadIO m, IsFileFilter o) => o -> m FileFilter

-- | Creates a new <a>FileFilter</a> with no rules added to it. Such a
--   filter doesn’t accept any files, so is not particularly useful until
--   you add rules with <a>fileFilterAddMimeType</a>,
--   <a>fileFilterAddPattern</a>, or <a>fileFilterAddCustom</a>. To create
--   a filter that accepts any file, use:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GtkFileFilter *filter = gtk_file_filter_new ();
--   gtk_file_filter_add_pattern (filter, "*");
--   </pre>
--   
--   <i>Since: 2.4</i>
fileFilterNew :: (HasCallStack, MonadIO m) => m FileFilter

-- | Deserialize a file filter from an a{sv} variant in the format produced
--   by <a>fileFilterToGvariant</a>.
--   
--   <i>Since: 3.22</i>
fileFilterNewFromGvariant :: (HasCallStack, MonadIO m) => GVariant -> m FileFilter

-- | Adds a rule allowing a given mime type to <i><tt>filter</tt></i>.
--   
--   <i>Since: 2.4</i>
fileFilterAddMimeType :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> Text -> m ()

-- | Adds a rule allowing a shell style glob to a filter.
--   
--   <i>Since: 2.4</i>
fileFilterAddPattern :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> Text -> m ()

-- | Adds a rule allowing image files in the formats supported by
--   GdkPixbuf.
--   
--   <i>Since: 2.6</i>
fileFilterAddPixbufFormats :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> m ()

-- | Tests whether a file should be displayed according to
--   <i><tt>filter</tt></i>. The <a>FileFilterInfo</a>
--   <i><tt>filterInfo</tt></i> should include the fields returned from
--   <a>fileFilterGetNeeded</a>.
--   
--   This function will not typically be used by applications; it is
--   intended principally for use in the implementation of
--   <a>FileChooser</a>.
--   
--   <i>Since: 2.4</i>
fileFilterFilter :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> FileFilterInfo -> m Bool

-- | Gets the human-readable name for the filter. See
--   <a>fileFilterSetName</a>.
--   
--   <i>Since: 2.4</i>
fileFilterGetName :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> m (Maybe Text)

-- | Gets the fields that need to be filled in for the
--   <a>FileFilterInfo</a> passed to <a>fileFilterFilter</a>
--   
--   This function will not typically be used by applications; it is
--   intended principally for use in the implementation of
--   <a>FileChooser</a>.
--   
--   <i>Since: 2.4</i>
fileFilterGetNeeded :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> m [FileFilterFlags]

-- | Sets the human-readable name of the filter; this is the string that
--   will be displayed in the file selector user interface if there is a
--   selectable list of filters.
--   
--   <i>Since: 2.4</i>
fileFilterSetName :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> Maybe Text -> m ()

-- | Serialize a file filter to an a{sv} variant.
--   
--   <i>Since: 3.22</i>
fileFilterToGvariant :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> m GVariant

-- | Cast to <a>Expander</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toExpander :: (MonadIO m, IsExpander o) => o -> m Expander

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> expander #activate callback
--   </pre>
onExpanderActivate :: (IsExpander a, MonadIO m) => a -> ((?self :: a) => ExpanderActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> expander #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterExpanderActivate :: (IsExpander a, MonadIO m) => a -> ((?self :: a) => ExpanderActivateCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>expanded</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> expander #expanded
--   </pre>
getExpanderExpanded :: (MonadIO m, IsExpander o) => o -> m Bool

-- | Set the value of the “<tt>expanded</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> expander [ #expanded <a>:=</a> value ]
--   </pre>
setExpanderExpanded :: (MonadIO m, IsExpander o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>expanded</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructExpanderExpanded :: (IsExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> expander #label
--   </pre>
getExpanderLabel :: (MonadIO m, IsExpander o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> expander [ #label <a>:=</a> value ]
--   </pre>
setExpanderLabel :: (MonadIO m, IsExpander o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructExpanderLabel :: (IsExpander o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>label</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #label
--   </pre>
clearExpanderLabel :: (MonadIO m, IsExpander o) => o -> m ()

-- | Get the value of the “<tt>label-fill</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> expander #labelFill
--   </pre>
getExpanderLabelFill :: (MonadIO m, IsExpander o) => o -> m Bool

-- | Set the value of the “<tt>label-fill</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> expander [ #labelFill <a>:=</a> value ]
--   </pre>
setExpanderLabelFill :: (MonadIO m, IsExpander o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label-fill</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructExpanderLabelFill :: (IsExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>label-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> expander #labelWidget
--   </pre>
getExpanderLabelWidget :: (MonadIO m, IsExpander o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>label-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> expander [ #labelWidget <a>:=</a> value ]
--   </pre>
setExpanderLabelWidget :: (MonadIO m, IsExpander o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label-widget</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructExpanderLabelWidget :: (IsExpander o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>label-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #labelWidget
--   </pre>
clearExpanderLabelWidget :: (MonadIO m, IsExpander o) => o -> m ()

-- | Get the value of the “<tt>resize-toplevel</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> expander #resizeToplevel
--   </pre>
getExpanderResizeToplevel :: (MonadIO m, IsExpander o) => o -> m Bool

-- | Set the value of the “<tt>resize-toplevel</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> expander [ #resizeToplevel <a>:=</a> value ]
--   </pre>
setExpanderResizeToplevel :: (MonadIO m, IsExpander o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>resize-toplevel</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructExpanderResizeToplevel :: (IsExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> expander #spacing
--   </pre>
getExpanderSpacing :: (MonadIO m, IsExpander o) => o -> m Int32

-- | Set the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> expander [ #spacing <a>:=</a> value ]
--   </pre>
setExpanderSpacing :: (MonadIO m, IsExpander o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>spacing</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructExpanderSpacing :: (IsExpander o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> expander #useMarkup
--   </pre>
getExpanderUseMarkup :: (MonadIO m, IsExpander o) => o -> m Bool

-- | Set the value of the “<tt>use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> expander [ #useMarkup <a>:=</a> value ]
--   </pre>
setExpanderUseMarkup :: (MonadIO m, IsExpander o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-markup</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructExpanderUseMarkup :: (IsExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> expander #useUnderline
--   </pre>
getExpanderUseUnderline :: (MonadIO m, IsExpander o) => o -> m Bool

-- | Set the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> expander [ #useUnderline <a>:=</a> value ]
--   </pre>
setExpanderUseUnderline :: (MonadIO m, IsExpander o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-underline</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructExpanderUseUnderline :: (IsExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new expander using <i><tt>label</tt></i> as the text of the
--   label.
--   
--   <i>Since: 2.4</i>
expanderNew :: (HasCallStack, MonadIO m) => Maybe Text -> m Expander

-- | Creates a new expander using <i><tt>label</tt></i> as the text of the
--   label. If characters in <i><tt>label</tt></i> are preceded by an
--   underscore, they are underlined. If you need a literal underscore
--   character in a label, use “__” (two underscores). The first underlined
--   character represents a keyboard accelerator called a mnemonic.
--   Pressing Alt and that key activates the button.
--   
--   <i>Since: 2.4</i>
expanderNewWithMnemonic :: (HasCallStack, MonadIO m) => Maybe Text -> m Expander

-- | Queries a <a>Expander</a> and returns its current state. Returns
--   <a>True</a> if the child widget is revealed.
--   
--   See <a>expanderSetExpanded</a>.
--   
--   <i>Since: 2.4</i>
expanderGetExpanded :: (HasCallStack, MonadIO m, IsExpander a) => a -> m Bool

-- | Fetches the text from a label widget including any embedded underlines
--   indicating mnemonics and Pango markup, as set by
--   <a>expanderSetLabel</a>. If the label text has not been set the return
--   value will be <a>Nothing</a>. This will be the case if you create an
--   empty button with <a>buttonNew</a> to use as a container.
--   
--   Note that this function behaved differently in versions prior to 2.14
--   and used to return the label text stripped of embedded underlines
--   indicating mnemonics and Pango markup. This problem can be avoided by
--   fetching the label text directly from the label widget.
--   
--   <i>Since: 2.4</i>
expanderGetLabel :: (HasCallStack, MonadIO m, IsExpander a) => a -> m (Maybe Text)

-- | Returns whether the label widget will fill all available horizontal
--   space allocated to <i><tt>expander</tt></i>.
--   
--   <i>Since: 2.22</i>
expanderGetLabelFill :: (HasCallStack, MonadIO m, IsExpander a) => a -> m Bool

-- | Retrieves the label widget for the frame. See
--   <a>expanderSetLabelWidget</a>.
--   
--   <i>Since: 2.4</i>
expanderGetLabelWidget :: (HasCallStack, MonadIO m, IsExpander a) => a -> m (Maybe Widget)

-- | Returns whether the expander will resize the toplevel widget
--   containing the expander upon resizing and collpasing.
--   
--   <i>Since: 3.2</i>
expanderGetResizeToplevel :: (HasCallStack, MonadIO m, IsExpander a) => a -> m Bool

-- | Gets the value set by <a>expanderSetSpacing</a>.
--   
--   <i>Since: 2.4</i>
expanderGetSpacing :: (HasCallStack, MonadIO m, IsExpander a) => a -> m Int32

-- | Returns whether the label’s text is interpreted as marked up with the
--   [Pango text markup language][PangoMarkupFormat]. See
--   <a>expanderSetUseMarkup</a>.
--   
--   <i>Since: 2.4</i>
expanderGetUseMarkup :: (HasCallStack, MonadIO m, IsExpander a) => a -> m Bool

-- | Returns whether an embedded underline in the expander label indicates
--   a mnemonic. See <a>expanderSetUseUnderline</a>.
--   
--   <i>Since: 2.4</i>
expanderGetUseUnderline :: (HasCallStack, MonadIO m, IsExpander a) => a -> m Bool

-- | Sets the state of the expander. Set to <a>True</a>, if you want the
--   child widget to be revealed, and <a>False</a> if you want the child
--   widget to be hidden.
--   
--   <i>Since: 2.4</i>
expanderSetExpanded :: (HasCallStack, MonadIO m, IsExpander a) => a -> Bool -> m ()

-- | Sets the text of the label of the expander to <i><tt>label</tt></i>.
--   
--   This will also clear any previously set labels.
--   
--   <i>Since: 2.4</i>
expanderSetLabel :: (HasCallStack, MonadIO m, IsExpander a) => a -> Maybe Text -> m ()

-- | Sets whether the label widget should fill all available horizontal
--   space allocated to <i><tt>expander</tt></i>.
--   
--   Note that this function has no effect since 3.20.
--   
--   <i>Since: 2.22</i>
expanderSetLabelFill :: (HasCallStack, MonadIO m, IsExpander a) => a -> Bool -> m ()

-- | Set the label widget for the expander. This is the widget that will
--   appear embedded alongside the expander arrow.
--   
--   <i>Since: 2.4</i>
expanderSetLabelWidget :: (HasCallStack, MonadIO m, IsExpander a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether the expander will resize the toplevel widget containing
--   the expander upon resizing and collpasing.
--   
--   <i>Since: 3.2</i>
expanderSetResizeToplevel :: (HasCallStack, MonadIO m, IsExpander a) => a -> Bool -> m ()

-- | Sets the spacing field of <i><tt>expander</tt></i>, which is the
--   number of pixels to place between expander and the child.
--   
--   <i>Since: 2.4</i>
expanderSetSpacing :: (HasCallStack, MonadIO m, IsExpander a) => a -> Int32 -> m ()

-- | Sets whether the text of the label contains markup in [Pango’s text
--   markup language][PangoMarkupFormat]. See <a>labelSetMarkup</a>.
--   
--   <i>Since: 2.4</i>
expanderSetUseMarkup :: (HasCallStack, MonadIO m, IsExpander a) => a -> Bool -> m ()

-- | If true, an underline in the text of the expander label indicates the
--   next character should be used for the mnemonic accelerator key.
--   
--   <i>Since: 2.4</i>
expanderSetUseUnderline :: (HasCallStack, MonadIO m, IsExpander a) => a -> Bool -> m ()

-- | Cast to <a>EventController</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toEventController :: (MonadIO m, IsEventController o) => o -> m EventController

-- | Get the value of the “<tt>propagation-phase</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> eventController #propagationPhase
--   </pre>
getEventControllerPropagationPhase :: (MonadIO m, IsEventController o) => o -> m PropagationPhase

-- | Set the value of the “<tt>propagation-phase</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> eventController [ #propagationPhase <a>:=</a> value ]
--   </pre>
setEventControllerPropagationPhase :: (MonadIO m, IsEventController o) => o -> PropagationPhase -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>propagation-phase</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEventControllerPropagationPhase :: (IsEventController o, MonadIO m) => PropagationPhase -> m (GValueConstruct o)

-- | Get the value of the “<tt>widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> eventController #widget
--   </pre>
getEventControllerWidget :: (MonadIO m, IsEventController o) => o -> m Widget

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>widget</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEventControllerWidget :: (IsEventController o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Gets the propagation phase at which <i><tt>controller</tt></i> handles
--   events.
--   
--   <i>Since: 3.14</i>
eventControllerGetPropagationPhase :: (HasCallStack, MonadIO m, IsEventController a) => a -> m PropagationPhase

-- | Sets the propagation phase at which a controller handles events.
--   
--   If <i><tt>phase</tt></i> is <a>PropagationPhaseNone</a>, no automatic
--   event handling will be performed, but other additional gesture
--   maintenance will. In that phase, the events can be managed by calling
--   <a>eventControllerHandleEvent</a>.
--   
--   <i>Since: 3.14</i>
eventControllerSetPropagationPhase :: (HasCallStack, MonadIO m, IsEventController a) => a -> PropagationPhase -> m ()

-- | Cast to <a>PadController</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPadController :: (MonadIO m, IsPadController o) => o -> m PadController

-- | Get the value of the “<tt>action-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> padController #actionGroup
--   </pre>
getPadControllerActionGroup :: (MonadIO m, IsPadController o) => o -> m (Maybe ActionGroup)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>action-group</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPadControllerActionGroup :: (IsPadController o, MonadIO m, IsActionGroup a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>pad</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> padController #pad
--   </pre>
getPadControllerPad :: (MonadIO m, IsPadController o) => o -> m (Maybe Device)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pad</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPadControllerPad :: (IsPadController o, MonadIO m, IsDevice a) => a -> m (GValueConstruct o)

-- | Creates a new <a>PadController</a> that will associate events from
--   <i><tt>pad</tt></i> to actions. A <a>Nothing</a> pad may be provided
--   so the controller manages all pad devices generically, it is
--   discouraged to mix <a>PadController</a> objects with <a>Nothing</a>
--   and non-<a>Nothing</a> <i><tt>pad</tt></i> argument on the same
--   <i><tt>window</tt></i>, as execution order is not guaranteed.
--   
--   The <a>PadController</a> is created with no mapped actions. In order
--   to map pad events to actions, use <a>padControllerSetActionEntries</a>
--   or <a>padControllerSetAction</a>.
--   
--   <i>Since: 3.22</i>
padControllerNew :: (HasCallStack, MonadIO m, IsWindow a, IsActionGroup b, IsDevice c) => a -> b -> Maybe c -> m PadController

-- | Adds an individual action to <i><tt>controller</tt></i>. This action
--   will only be activated if the given button/ring/strip number in
--   <i><tt>index</tt></i> is interacted while the current mode is
--   <i><tt>mode</tt></i>. -1 may be used for simple cases, so the action
--   is triggered on all modes.
--   
--   The given <i><tt>label</tt></i> should be considered user-visible, so
--   internationalization rules apply. Some windowing systems may be able
--   to use those for user feedback.
--   
--   <i>Since: 3.22</i>
padControllerSetAction :: (HasCallStack, MonadIO m, IsPadController a) => a -> PadActionType -> Int32 -> Int32 -> Text -> Text -> m ()

-- | This is a convenience function to add a group of action entries on
--   <i><tt>controller</tt></i>. See <a>PadActionEntry</a> and
--   <a>padControllerSetAction</a>.
--   
--   <i>Since: 3.22</i>
padControllerSetActionEntries :: (HasCallStack, MonadIO m, IsPadController a) => a -> [PadActionEntry] -> m ()

-- | Cast to <a>Gesture</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toGesture :: (MonadIO m, IsGesture o) => o -> m Gesture

-- | Connect a signal handler for the <a>begin</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> gesture #begin callback
--   </pre>
onGestureBegin :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>begin</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gesture #begin callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureBegin :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cancel</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gesture #cancel callback
--   </pre>
onGestureCancel :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureCancelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cancel</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gesture #cancel callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureCancel :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureCancelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>end</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> gesture #end callback
--   </pre>
onGestureEnd :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>end</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gesture #end callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureEnd :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>sequenceStateChanged</a> signal,
--   to be run before the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> gesture #sequenceStateChanged callback
--   </pre>
onGestureSequenceStateChanged :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureSequenceStateChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>sequenceStateChanged</a> signal,
--   to be run after the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> gesture #sequenceStateChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureSequenceStateChanged :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureSequenceStateChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>update</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gesture #update callback
--   </pre>
onGestureUpdate :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureUpdateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>update</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gesture #update callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureUpdate :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureUpdateCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>n-points</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gesture #nPoints
--   </pre>
getGestureNPoints :: (MonadIO m, IsGesture o) => o -> m Word32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>n-points</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructGestureNPoints :: (IsGesture o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>window</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gesture #window
--   </pre>
getGestureWindow :: (MonadIO m, IsGesture o) => o -> m (Maybe Window)

-- | Set the value of the “<tt>window</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gesture [ #window <a>:=</a> value ]
--   </pre>
setGestureWindow :: (MonadIO m, IsGesture o, IsWindow a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>window</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructGestureWindow :: (IsGesture o, MonadIO m, IsWindow a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>window</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #window
--   </pre>
clearGestureWindow :: (MonadIO m, IsGesture o) => o -> m ()

-- | If there are touch sequences being currently handled by
--   <i><tt>gesture</tt></i>, this function returns <a>True</a> and fills
--   in <i><tt>rect</tt></i> with the bounding box containing all active
--   touches. Otherwise, <a>False</a> will be returned.
--   
--   Note: This function will yield unexpected results on touchpad
--   gestures. Since there is no correlation between physical and pixel
--   distances, these will look as if constrained in an infinitely small
--   area, <i><tt>rect</tt></i> width and height will thus be 0 regardless
--   of the number of touchpoints.
--   
--   <i>Since: 3.14</i>
gestureGetBoundingBox :: (HasCallStack, MonadIO m, IsGesture a) => a -> m (Bool, Rectangle)

-- | If there are touch sequences being currently handled by
--   <i><tt>gesture</tt></i>, this function returns <a>True</a> and fills
--   in <i><tt>x</tt></i> and <i><tt>y</tt></i> with the center of the
--   bounding box containing all active touches. Otherwise, <a>False</a>
--   will be returned.
--   
--   <i>Since: 3.14</i>
gestureGetBoundingBoxCenter :: (HasCallStack, MonadIO m, IsGesture a) => a -> m (Bool, Double, Double)

-- | Returns the master <a>Device</a> that is currently operating on
--   <i><tt>gesture</tt></i>, or <a>Nothing</a> if the gesture is not being
--   interacted.
--   
--   <i>Since: 3.14</i>
gestureGetDevice :: (HasCallStack, MonadIO m, IsGesture a) => a -> m (Maybe Device)

-- | Returns all gestures in the group of <i><tt>gesture</tt></i>
--   
--   <i>Since: 3.14</i>
gestureGetGroup :: (HasCallStack, MonadIO m, IsGesture a) => a -> m [Gesture]

-- | Returns the last event that was processed for
--   <i><tt>sequence</tt></i>.
--   
--   Note that the returned pointer is only valid as long as the
--   <i><tt>sequence</tt></i> is still interpreted by the
--   <i><tt>gesture</tt></i>. If in doubt, you should make a copy of the
--   event.
gestureGetLastEvent :: (HasCallStack, MonadIO m, IsGesture a) => a -> Maybe EventSequence -> m (Maybe Event)

-- | Returns the <a>EventSequence</a> that was last updated on
--   <i><tt>gesture</tt></i>.
--   
--   <i>Since: 3.14</i>
gestureGetLastUpdatedSequence :: (HasCallStack, MonadIO m, IsGesture a) => a -> m (Maybe EventSequence)

-- | If <i><tt>sequence</tt></i> is currently being interpreted by
--   <i><tt>gesture</tt></i>, this function returns <a>True</a> and fills
--   in <i><tt>x</tt></i> and <i><tt>y</tt></i> with the last coordinates
--   stored for that event sequence. The coordinates are always relative to
--   the widget allocation.
--   
--   <i>Since: 3.14</i>
gestureGetPoint :: (HasCallStack, MonadIO m, IsGesture a) => a -> Maybe EventSequence -> m (Bool, Double, Double)

-- | Returns the <i><tt>sequence</tt></i> state, as seen by
--   <i><tt>gesture</tt></i>.
--   
--   <i>Since: 3.14</i>
gestureGetSequenceState :: (HasCallStack, MonadIO m, IsGesture a) => a -> EventSequence -> m EventSequenceState

-- | Returns the list of <tt><i>GdkEventSequences</i></tt> currently being
--   interpreted by <i><tt>gesture</tt></i>.
--   
--   <i>Since: 3.14</i>
gestureGetSequences :: (HasCallStack, MonadIO m, IsGesture a) => a -> m [EventSequence]

-- | Returns the user-defined window that receives the events handled by
--   <i><tt>gesture</tt></i>. See <a>gestureSetWindow</a> for more
--   information.
--   
--   <i>Since: 3.14</i>
gestureGetWindow :: (HasCallStack, MonadIO m, IsGesture a) => a -> m (Maybe Window)

-- | Adds <i><tt>gesture</tt></i> to the same group than
--   <i><tt>groupGesture</tt></i>. Gestures are by default isolated in
--   their own groups.
--   
--   When gestures are grouped, the state of
--   <tt><i>GdkEventSequences</i></tt> is kept in sync for all of those, so
--   calling <a>gestureSetSequenceState</a>, on one will transfer the same
--   value to the others.
--   
--   Groups also perform an "implicit grabbing" of sequences, if a
--   <a>EventSequence</a> state is set to
--   <tt><i>GTK_EVENT_SEQUENCE_CLAIMED</i></tt> on one group, every other
--   gesture group attached to the same <a>Widget</a> will switch the state
--   for that sequence to <tt><i>GTK_EVENT_SEQUENCE_DENIED</i></tt>.
--   
--   <i>Since: 3.14</i>
gestureGroup :: (HasCallStack, MonadIO m, IsGesture a, IsGesture b) => a -> b -> m ()

-- | Returns <a>True</a> if <i><tt>gesture</tt></i> is currently handling
--   events corresponding to <i><tt>sequence</tt></i>.
--   
--   <i>Since: 3.14</i>
gestureHandlesSequence :: (HasCallStack, MonadIO m, IsGesture a) => a -> Maybe EventSequence -> m Bool

-- | Returns <a>True</a> if both gestures pertain to the same group.
--   
--   <i>Since: 3.14</i>
gestureIsGroupedWith :: (HasCallStack, MonadIO m, IsGesture a, IsGesture b) => a -> b -> m Bool

-- | Returns <a>True</a> if the gesture is currently recognized. A gesture
--   is recognized if there are as many interacting touch sequences as
--   required by <i><tt>gesture</tt></i>, and
--   <a>Gesture</a>::<tt><i>check</i></tt> returned <a>True</a> for the
--   sequences being currently interpreted.
--   
--   <i>Since: 3.14</i>
gestureIsRecognized :: (HasCallStack, MonadIO m, IsGesture a) => a -> m Bool

-- | Sets the state of <i><tt>sequence</tt></i> in <i><tt>gesture</tt></i>.
--   Sequences start in state <tt><i>GTK_EVENT_SEQUENCE_NONE</i></tt>, and
--   whenever they change state, they can never go back to that state.
--   Likewise, sequences in state <tt><i>GTK_EVENT_SEQUENCE_DENIED</i></tt>
--   cannot turn back to a not denied state. With these rules, the lifetime
--   of an event sequence is constrained to the next four:
--   
--   <ul>
--   <li>None</li>
--   <li>None → Denied</li>
--   <li>None → Claimed</li>
--   <li>None → Claimed → Denied</li>
--   </ul>
--   
--   Note: Due to event handling ordering, it may be unsafe to set the
--   state on another gesture within a <a>Gesture::begin</a> signal
--   handler, as the callback might be executed before the other gesture
--   knows about the sequence. A safe way to perform this could be:
--   
--   <pre>
--   static void
--   first_gesture_begin_cb (GtkGesture       *first_gesture,
--                           GdkEventSequence *sequence,
--                           gpointer          user_data)
--   {
--     gtk_gesture_set_sequence_state (first_gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);
--     gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED);
--   }
--   
--   static void
--   second_gesture_begin_cb (GtkGesture       *second_gesture,
--                            GdkEventSequence *sequence,
--                            gpointer          user_data)
--   {
--     if (gtk_gesture_get_sequence_state (first_gesture, sequence) == GTK_EVENT_SEQUENCE_CLAIMED)
--       gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED);
--   }
--   </pre>
--   
--   If both gestures are in the same group, just set the state on the
--   gesture emitting the event, the sequence will be already be
--   initialized to the group's global state when the second gesture
--   processes the event.
--   
--   <i>Since: 3.14</i>
gestureSetSequenceState :: (HasCallStack, MonadIO m, IsGesture a) => a -> EventSequence -> EventSequenceState -> m Bool

-- | Sets the state of all sequences that <i><tt>gesture</tt></i> is
--   currently interacting with. See <a>gestureSetSequenceState</a> for
--   more details on sequence states.
--   
--   <i>Since: 3.14</i>
gestureSetState :: (HasCallStack, MonadIO m, IsGesture a) => a -> EventSequenceState -> m Bool

-- | Sets a specific window to receive events about, so
--   <i><tt>gesture</tt></i> will effectively handle only events targeting
--   <i><tt>window</tt></i>, or a child of it. <i><tt>window</tt></i> must
--   pertain to <a>eventControllerGetWidget</a>.
--   
--   <i>Since: 3.14</i>
gestureSetWindow :: (HasCallStack, MonadIO m, IsGesture a, IsWindow b) => a -> Maybe b -> m ()

-- | Separates <i><tt>gesture</tt></i> into an isolated group.
--   
--   <i>Since: 3.14</i>
gestureUngroup :: (HasCallStack, MonadIO m, IsGesture a) => a -> m ()

-- | Cast to <a>GestureZoom</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGestureZoom :: (MonadIO m, IsGestureZoom o) => o -> m GestureZoom

-- | Connect a signal handler for the <a>scaleChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureZoom #scaleChanged callback
--   </pre>
onGestureZoomScaleChanged :: (IsGestureZoom a, MonadIO m) => a -> ((?self :: a) => GestureZoomScaleChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scaleChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureZoom #scaleChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureZoomScaleChanged :: (IsGestureZoom a, MonadIO m) => a -> ((?self :: a) => GestureZoomScaleChangedCallback) -> m SignalHandlerId

-- | Returns a newly created <a>Gesture</a> that recognizes zoom in/out
--   gestures (usually known as pinch/zoom).
--   
--   <i>Since: 3.14</i>
gestureZoomNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m GestureZoom

-- | If <i><tt>gesture</tt></i> is active, this function returns the
--   zooming difference since the gesture was recognized (hence the
--   starting point is considered 1:1). If <i><tt>gesture</tt></i> is not
--   active, 1 is returned.
--   
--   <i>Since: 3.14</i>
gestureZoomGetScaleDelta :: (HasCallStack, MonadIO m, IsGestureZoom a) => a -> m Double

-- | Cast to <a>GestureSingle</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGestureSingle :: (MonadIO m, IsGestureSingle o) => o -> m GestureSingle

-- | Get the value of the “<tt>button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gestureSingle #button
--   </pre>
getGestureSingleButton :: (MonadIO m, IsGestureSingle o) => o -> m Word32

-- | Set the value of the “<tt>button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gestureSingle [ #button <a>:=</a> value ]
--   </pre>
setGestureSingleButton :: (MonadIO m, IsGestureSingle o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>button</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructGestureSingleButton :: (IsGestureSingle o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>exclusive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gestureSingle #exclusive
--   </pre>
getGestureSingleExclusive :: (MonadIO m, IsGestureSingle o) => o -> m Bool

-- | Set the value of the “<tt>exclusive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gestureSingle [ #exclusive <a>:=</a> value ]
--   </pre>
setGestureSingleExclusive :: (MonadIO m, IsGestureSingle o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>exclusive</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructGestureSingleExclusive :: (IsGestureSingle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>touch-only</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gestureSingle #touchOnly
--   </pre>
getGestureSingleTouchOnly :: (MonadIO m, IsGestureSingle o) => o -> m Bool

-- | Set the value of the “<tt>touch-only</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gestureSingle [ #touchOnly <a>:=</a> value ]
--   </pre>
setGestureSingleTouchOnly :: (MonadIO m, IsGestureSingle o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>touch-only</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructGestureSingleTouchOnly :: (IsGestureSingle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Returns the button number <i><tt>gesture</tt></i> listens for, or 0 if
--   <i><tt>gesture</tt></i> reacts to any button press.
--   
--   <i>Since: 3.14</i>
gestureSingleGetButton :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> m Word32

-- | Returns the button number currently interacting with
--   <i><tt>gesture</tt></i>, or 0 if there is none.
--   
--   <i>Since: 3.14</i>
gestureSingleGetCurrentButton :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> m Word32

-- | Returns the event sequence currently interacting with
--   <i><tt>gesture</tt></i>. This is only meaningful if
--   <a>gestureIsActive</a> returns <a>True</a>.
--   
--   <i>Since: 3.14</i>
gestureSingleGetCurrentSequence :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> m (Maybe EventSequence)

-- | Gets whether a gesture is exclusive. For more information, see
--   <a>gestureSingleSetExclusive</a>.
--   
--   <i>Since: 3.14</i>
gestureSingleGetExclusive :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> m Bool

-- | Returns <a>True</a> if the gesture is only triggered by touch events.
--   
--   <i>Since: 3.14</i>
gestureSingleGetTouchOnly :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> m Bool

-- | Sets the button number <i><tt>gesture</tt></i> listens to. If non-0,
--   every button press from a different button number will be ignored.
--   Touch events implicitly match with button 1.
--   
--   <i>Since: 3.14</i>
gestureSingleSetButton :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> Word32 -> m ()

-- | Sets whether <i><tt>gesture</tt></i> is exclusive. An exclusive
--   gesture will only handle pointer and "pointer emulated" touch events,
--   so at any given time, there is only one sequence able to interact with
--   those.
--   
--   <i>Since: 3.14</i>
gestureSingleSetExclusive :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> Bool -> m ()

-- | If <i><tt>touchOnly</tt></i> is <a>True</a>, <i><tt>gesture</tt></i>
--   will only handle events of type <tt><i>GDK_TOUCH_BEGIN</i></tt>,
--   <tt><i>GDK_TOUCH_UPDATE</i></tt> or <tt><i>GDK_TOUCH_END</i></tt>. If
--   <a>False</a>, mouse events will be handled too.
--   
--   <i>Since: 3.14</i>
gestureSingleSetTouchOnly :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> Bool -> m ()

-- | Cast to <a>GestureSwipe</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGestureSwipe :: (MonadIO m, IsGestureSwipe o) => o -> m GestureSwipe

-- | Connect a signal handler for the <a>swipe</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> gestureSwipe #swipe callback
--   </pre>
onGestureSwipeSwipe :: (IsGestureSwipe a, MonadIO m) => a -> ((?self :: a) => GestureSwipeSwipeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>swipe</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureSwipe #swipe callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureSwipeSwipe :: (IsGestureSwipe a, MonadIO m) => a -> ((?self :: a) => GestureSwipeSwipeCallback) -> m SignalHandlerId

-- | Returns a newly created <a>Gesture</a> that recognizes swipes.
--   
--   <i>Since: 3.14</i>
gestureSwipeNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m GestureSwipe

-- | If the gesture is recognized, this function returns <a>True</a> and
--   fill in <i><tt>velocityX</tt></i> and <i><tt>velocityY</tt></i> with
--   the recorded velocity, as per the last event(s) processed.
--   
--   <i>Since: 3.14</i>
gestureSwipeGetVelocity :: (HasCallStack, MonadIO m, IsGestureSwipe a) => a -> m (Bool, Double, Double)

-- | Cast to <a>GestureStylus</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGestureStylus :: (MonadIO m, IsGestureStylus o) => o -> m GestureStylus

-- | Connect a signal handler for the <a>down</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> gestureStylus #down callback
--   </pre>
onGestureStylusDown :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusDownCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>down</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureStylus #down callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureStylusDown :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusDownCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>motion</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureStylus #motion callback
--   </pre>
onGestureStylusMotion :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusMotionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>motion</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureStylus #motion callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureStylusMotion :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusMotionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>proximity</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureStylus #proximity callback
--   </pre>
onGestureStylusProximity :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusProximityCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>proximity</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureStylus #proximity callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureStylusProximity :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusProximityCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>up</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> gestureStylus #up callback
--   </pre>
onGestureStylusUp :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusUpCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>up</a> signal, to be run after the
--   default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureStylus #up callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureStylusUp :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusUpCallback) -> m SignalHandlerId

-- | Creates a new <a>GestureStylus</a>.
--   
--   <i>Since: 3.24</i>
gestureStylusNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m GestureStylus

-- | Returns the current value for the requested <i><tt>axis</tt></i>. This
--   function must be called from either the
--   <a>GestureStylus</a>:<tt><i>down</i></tt>,
--   <a>GestureStylus</a>:<tt><i>motion</i></tt>,
--   <a>GestureStylus</a>:<tt><i>up</i></tt> or
--   <a>GestureStylus</a>:<tt><i>proximity</i></tt> signals.
--   
--   <i>Since: 3.24</i>
gestureStylusGetAxis :: (HasCallStack, MonadIO m, IsGestureStylus a) => a -> AxisUse -> m (Bool, Double)

-- | Returns the <a>DeviceTool</a> currently driving input through this
--   gesture. This function must be called from either the
--   <a>GestureStylus::down</a>, <a>GestureStylus::motion</a>,
--   <a>GestureStylus::up</a> or <a>GestureStylus::proximity</a> signal
--   handlers.
--   
--   <i>Since: 3.24</i>
gestureStylusGetDeviceTool :: (HasCallStack, MonadIO m, IsGestureStylus a) => a -> m (Maybe DeviceTool)

-- | Cast to <a>GestureRotate</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGestureRotate :: (MonadIO m, IsGestureRotate o) => o -> m GestureRotate

-- | Connect a signal handler for the <a>angleChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureRotate #angleChanged callback
--   </pre>
onGestureRotateAngleChanged :: (IsGestureRotate a, MonadIO m) => a -> ((?self :: a) => GestureRotateAngleChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>angleChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureRotate #angleChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureRotateAngleChanged :: (IsGestureRotate a, MonadIO m) => a -> ((?self :: a) => GestureRotateAngleChangedCallback) -> m SignalHandlerId

-- | Returns a newly created <a>Gesture</a> that recognizes 2-touch
--   rotation gestures.
--   
--   <i>Since: 3.14</i>
gestureRotateNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m GestureRotate

-- | If <i><tt>gesture</tt></i> is active, this function returns the angle
--   difference in radians since the gesture was first recognized. If
--   <i><tt>gesture</tt></i> is not active, 0 is returned.
--   
--   <i>Since: 3.14</i>
gestureRotateGetAngleDelta :: (HasCallStack, MonadIO m, IsGestureRotate a) => a -> m Double

-- | Cast to <a>GestureMultiPress</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toGestureMultiPress :: (MonadIO m, IsGestureMultiPress o) => o -> m GestureMultiPress

-- | Connect a signal handler for the <a>pressed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureMultiPress #pressed callback
--   </pre>
onGestureMultiPressPressed :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pressed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureMultiPress #pressed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureMultiPressPressed :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>released</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureMultiPress #released callback
--   </pre>
onGestureMultiPressReleased :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressReleasedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>released</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureMultiPress #released callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureMultiPressReleased :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressReleasedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>stopped</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureMultiPress #stopped callback
--   </pre>
onGestureMultiPressStopped :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressStoppedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>stopped</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureMultiPress #stopped callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureMultiPressStopped :: (IsGestureMultiPress a, MonadIO m) => a -> ((?self :: a) => GestureMultiPressStoppedCallback) -> m SignalHandlerId

-- | Returns a newly created <a>Gesture</a> that recognizes single and
--   multiple presses.
--   
--   <i>Since: 3.14</i>
gestureMultiPressNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m GestureMultiPress

-- | If an area was set through <a>gestureMultiPressSetArea</a>, this
--   function will return <a>True</a> and fill in <i><tt>rect</tt></i> with
--   the press area. See <a>gestureMultiPressSetArea</a> for more details
--   on what the press area represents.
--   
--   <i>Since: 3.14</i>
gestureMultiPressGetArea :: (HasCallStack, MonadIO m, IsGestureMultiPress a) => a -> m (Bool, Rectangle)

-- | If <i><tt>rect</tt></i> is non-<a>Nothing</a>, the press area will be
--   checked to be confined within the rectangle, otherwise the button
--   count will be reset so the press is seen as being the first one. If
--   <i><tt>rect</tt></i> is <a>Nothing</a>, the area will be reset to an
--   unrestricted state.
--   
--   Note: The rectangle is only used to determine whether any non-first
--   click falls within the expected area. This is not akin to an input
--   shape.
--   
--   <i>Since: 3.14</i>
gestureMultiPressSetArea :: (HasCallStack, MonadIO m, IsGestureMultiPress a) => a -> Maybe Rectangle -> m ()

-- | Cast to <a>GestureLongPress</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toGestureLongPress :: (MonadIO m, IsGestureLongPress o) => o -> m GestureLongPress

-- | Connect a signal handler for the <a>cancelled</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureLongPress #cancelled callback
--   </pre>
onGestureLongPressCancelled :: (IsGestureLongPress a, MonadIO m) => a -> ((?self :: a) => GestureLongPressCancelledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cancelled</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureLongPress #cancelled callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureLongPressCancelled :: (IsGestureLongPress a, MonadIO m) => a -> ((?self :: a) => GestureLongPressCancelledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pressed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureLongPress #pressed callback
--   </pre>
onGestureLongPressPressed :: (IsGestureLongPress a, MonadIO m) => a -> ((?self :: a) => GestureLongPressPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pressed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureLongPress #pressed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureLongPressPressed :: (IsGestureLongPress a, MonadIO m) => a -> ((?self :: a) => GestureLongPressPressedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>delay-factor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gestureLongPress #delayFactor
--   </pre>
getGestureLongPressDelayFactor :: (MonadIO m, IsGestureLongPress o) => o -> m Double

-- | Set the value of the “<tt>delay-factor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gestureLongPress [ #delayFactor <a>:=</a> value ]
--   </pre>
setGestureLongPressDelayFactor :: (MonadIO m, IsGestureLongPress o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>delay-factor</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGestureLongPressDelayFactor :: (IsGestureLongPress o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Returns a newly created <a>Gesture</a> that recognizes long presses.
--   
--   <i>Since: 3.14</i>
gestureLongPressNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m GestureLongPress

-- | Cast to <a>GestureDrag</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGestureDrag :: (MonadIO m, IsGestureDrag o) => o -> m GestureDrag

-- | Connect a signal handler for the <a>dragBegin</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureDrag #dragBegin callback
--   </pre>
onGestureDragDragBegin :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragBegin</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureDrag #dragBegin callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureDragDragBegin :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragEnd</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureDrag #dragEnd callback
--   </pre>
onGestureDragDragEnd :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragEnd</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureDrag #dragEnd callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureDragDragEnd :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragUpdate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureDrag #dragUpdate callback
--   </pre>
onGestureDragDragUpdate :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragUpdateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragUpdate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureDrag #dragUpdate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureDragDragUpdate :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragUpdateCallback) -> m SignalHandlerId

-- | Returns a newly created <a>Gesture</a> that recognizes drags.
--   
--   <i>Since: 3.14</i>
gestureDragNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m GestureDrag

-- | If the <i><tt>gesture</tt></i> is active, this function returns
--   <a>True</a> and fills in <i><tt>x</tt></i> and <i><tt>y</tt></i> with
--   the coordinates of the current point, as an offset to the starting
--   drag point.
--   
--   <i>Since: 3.14</i>
gestureDragGetOffset :: (HasCallStack, MonadIO m, IsGestureDrag a) => a -> m (Bool, Double, Double)

-- | If the <i><tt>gesture</tt></i> is active, this function returns
--   <a>True</a> and fills in <i><tt>x</tt></i> and <i><tt>y</tt></i> with
--   the drag start coordinates, in window-relative coordinates.
--   
--   <i>Since: 3.14</i>
gestureDragGetStartPoint :: (HasCallStack, MonadIO m, IsGestureDrag a) => a -> m (Bool, Double, Double)

-- | Cast to <a>GesturePan</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGesturePan :: (MonadIO m, IsGesturePan o) => o -> m GesturePan

-- | Connect a signal handler for the <a>pan</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> gesturePan #pan callback
--   </pre>
onGesturePanPan :: (IsGesturePan a, MonadIO m) => a -> ((?self :: a) => GesturePanPanCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pan</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gesturePan #pan callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGesturePanPan :: (IsGesturePan a, MonadIO m) => a -> ((?self :: a) => GesturePanPanCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>orientation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gesturePan #orientation
--   </pre>
getGesturePanOrientation :: (MonadIO m, IsGesturePan o) => o -> m Orientation

-- | Set the value of the “<tt>orientation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gesturePan [ #orientation <a>:=</a> value ]
--   </pre>
setGesturePanOrientation :: (MonadIO m, IsGesturePan o) => o -> Orientation -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>orientation</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGesturePanOrientation :: (IsGesturePan o, MonadIO m) => Orientation -> m (GValueConstruct o)

-- | Returns a newly created <a>Gesture</a> that recognizes pan gestures.
--   
--   <i>Since: 3.14</i>
gesturePanNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> Orientation -> m GesturePan

-- | Returns the orientation of the pan gestures that this
--   <i><tt>gesture</tt></i> expects.
--   
--   <i>Since: 3.14</i>
gesturePanGetOrientation :: (HasCallStack, MonadIO m, IsGesturePan a) => a -> m Orientation

-- | Sets the orientation to be expected on pan gestures.
--   
--   <i>Since: 3.14</i>
gesturePanSetOrientation :: (HasCallStack, MonadIO m, IsGesturePan a) => a -> Orientation -> m ()

-- | Cast to <a>EventControllerScroll</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toEventControllerScroll :: (MonadIO m, IsEventControllerScroll o) => o -> m EventControllerScroll

-- | Connect a signal handler for the <a>decelerate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerScroll #decelerate callback
--   </pre>
onEventControllerScrollDecelerate :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollDecelerateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>decelerate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerScroll #decelerate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerScrollDecelerate :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollDecelerateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scroll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerScroll #scroll callback
--   </pre>
onEventControllerScrollScroll :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scroll</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerScroll #scroll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerScrollScroll :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scrollBegin</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerScroll #scrollBegin callback
--   </pre>
onEventControllerScrollScrollBegin :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scrollBegin</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerScroll #scrollBegin callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerScrollScrollBegin :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scrollEnd</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerScroll #scrollEnd callback
--   </pre>
onEventControllerScrollScrollEnd :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scrollEnd</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerScroll #scrollEnd callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerScrollScrollEnd :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollEndCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> eventControllerScroll #flags
--   </pre>
getEventControllerScrollFlags :: (MonadIO m, IsEventControllerScroll o) => o -> m [EventControllerScrollFlags]

-- | Set the value of the “<tt>flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> eventControllerScroll [ #flags <a>:=</a> value ]
--   </pre>
setEventControllerScrollFlags :: (MonadIO m, IsEventControllerScroll o) => o -> [EventControllerScrollFlags] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>flags</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEventControllerScrollFlags :: (IsEventControllerScroll o, MonadIO m) => [EventControllerScrollFlags] -> m (GValueConstruct o)

-- | Creates a new event controller that will handle scroll events for the
--   given <i><tt>widget</tt></i>.
--   
--   <i>Since: 3.24</i>
eventControllerScrollNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> [EventControllerScrollFlags] -> m EventControllerScroll

-- | Gets the flags conditioning the scroll controller behavior.
--   
--   <i>Since: 3.24</i>
eventControllerScrollGetFlags :: (HasCallStack, MonadIO m, IsEventControllerScroll a) => a -> m [EventControllerScrollFlags]

-- | Sets the flags conditioning scroll controller behavior.
--   
--   <i>Since: 3.24</i>
eventControllerScrollSetFlags :: (HasCallStack, MonadIO m, IsEventControllerScroll a) => a -> [EventControllerScrollFlags] -> m ()

-- | Cast to <a>EventControllerMotion</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toEventControllerMotion :: (MonadIO m, IsEventControllerMotion o) => o -> m EventControllerMotion

-- | Connect a signal handler for the <a>enter</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerMotion #enter callback
--   </pre>
onEventControllerMotionEnter :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionEnterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>enter</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerMotion #enter callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerMotionEnter :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionEnterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>leave</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerMotion #leave callback
--   </pre>
onEventControllerMotionLeave :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>leave</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerMotion #leave callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerMotionLeave :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>motion</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerMotion #motion callback
--   </pre>
onEventControllerMotionMotion :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionMotionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>motion</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerMotion #motion callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerMotionMotion :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionMotionCallback) -> m SignalHandlerId

-- | Creates a new event controller that will handle motion events for the
--   given <i><tt>widget</tt></i>.
--   
--   <i>Since: 3.24</i>
eventControllerMotionNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m EventControllerMotion

-- | Cast to <a>EventControllerKey</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toEventControllerKey :: (MonadIO m, IsEventControllerKey o) => o -> m EventControllerKey

-- | Connect a signal handler for the <a>focusIn</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerKey #focusIn callback
--   </pre>
onEventControllerKeyFocusIn :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyFocusInCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>focusIn</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerKey #focusIn callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerKeyFocusIn :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyFocusInCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>focusOut</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerKey #focusOut callback
--   </pre>
onEventControllerKeyFocusOut :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyFocusOutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>focusOut</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerKey #focusOut callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerKeyFocusOut :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyFocusOutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>imUpdate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerKey #imUpdate callback
--   </pre>
onEventControllerKeyImUpdate :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyImUpdateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>imUpdate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerKey #imUpdate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerKeyImUpdate :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyImUpdateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>keyPressed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerKey #keyPressed callback
--   </pre>
onEventControllerKeyKeyPressed :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyKeyPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>keyPressed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerKey #keyPressed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerKeyKeyPressed :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyKeyPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>keyReleased</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerKey #keyReleased callback
--   </pre>
onEventControllerKeyKeyReleased :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyKeyReleasedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>keyReleased</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerKey #keyReleased callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerKeyKeyReleased :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyKeyReleasedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>modifiers</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerKey #modifiers callback
--   </pre>
onEventControllerKeyModifiers :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyModifiersCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>modifiers</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerKey #modifiers callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerKeyModifiers :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyModifiersCallback) -> m SignalHandlerId

-- | <i>No description available in the introspection data.</i>
eventControllerKeyNew :: (HasCallStack, MonadIO m, IsWidget a) => a -> m EventControllerKey

-- | <i>No description available in the introspection data.</i>
eventControllerKeyForward :: (HasCallStack, MonadIO m, IsEventControllerKey a, IsWidget b) => a -> b -> m Bool

-- | <i>No description available in the introspection data.</i>
eventControllerKeyGetGroup :: (HasCallStack, MonadIO m, IsEventControllerKey a) => a -> m Word32

-- | Gets the IM context of a key controller.
--   
--   <i>Since: 3.24</i>
eventControllerKeyGetImContext :: (HasCallStack, MonadIO m, IsEventControllerKey a) => a -> m IMContext

-- | <i>No description available in the introspection data.</i>
eventControllerKeySetImContext :: (HasCallStack, MonadIO m, IsEventControllerKey a, IsIMContext b) => a -> b -> m ()

-- | Cast to <a>EventBox</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toEventBox :: (MonadIO m, IsEventBox o) => o -> m EventBox

-- | Get the value of the “<tt>above-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> eventBox #aboveChild
--   </pre>
getEventBoxAboveChild :: (MonadIO m, IsEventBox o) => o -> m Bool

-- | Set the value of the “<tt>above-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> eventBox [ #aboveChild <a>:=</a> value ]
--   </pre>
setEventBoxAboveChild :: (MonadIO m, IsEventBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>above-child</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructEventBoxAboveChild :: (IsEventBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible-window</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> eventBox #visibleWindow
--   </pre>
getEventBoxVisibleWindow :: (MonadIO m, IsEventBox o) => o -> m Bool

-- | Set the value of the “<tt>visible-window</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> eventBox [ #visibleWindow <a>:=</a> value ]
--   </pre>
setEventBoxVisibleWindow :: (MonadIO m, IsEventBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible-window</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEventBoxVisibleWindow :: (IsEventBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>EventBox</a>.
eventBoxNew :: (HasCallStack, MonadIO m) => m EventBox

-- | Returns whether the event box window is above or below the windows of
--   its child. See <a>eventBoxSetAboveChild</a> for details.
--   
--   <i>Since: 2.4</i>
eventBoxGetAboveChild :: (HasCallStack, MonadIO m, IsEventBox a) => a -> m Bool

-- | Returns whether the event box has a visible window. See
--   <a>eventBoxSetVisibleWindow</a> for details.
--   
--   <i>Since: 2.4</i>
eventBoxGetVisibleWindow :: (HasCallStack, MonadIO m, IsEventBox a) => a -> m Bool

-- | Set whether the event box window is positioned above the windows of
--   its child, as opposed to below it. If the window is above, all events
--   inside the event box will go to the event box. If the window is below,
--   events in windows of child widgets will first got to that widget, and
--   then to its parents.
--   
--   The default is to keep the window below the child.
--   
--   <i>Since: 2.4</i>
eventBoxSetAboveChild :: (HasCallStack, MonadIO m, IsEventBox a) => a -> Bool -> m ()

-- | Set whether the event box uses a visible or invisible child window.
--   The default is to use visible windows.
--   
--   In an invisible window event box, the window that the event box
--   creates is a <a>WindowWindowClassInputOnly</a> window, which means
--   that it is invisible and only serves to receive events.
--   
--   A visible window event box creates a visible
--   (<a>WindowWindowClassInputOutput</a>) window that acts as the parent
--   window for all the widgets contained in the event box.
--   
--   You should generally make your event box invisible if you just want to
--   trap events. Creating a visible window may cause artifacts that are
--   visible to the user, especially if the user is using a theme with
--   gradients or pixmaps.
--   
--   The main reason to create a non input-only event box is if you want to
--   set the background to a different color or draw on it.
--   
--   There is one unexpected issue for an invisible event box that has its
--   window below the child. (See <a>eventBoxSetAboveChild</a>.) Since the
--   input-only window is not an ancestor window of any windows that
--   descendent widgets of the event box create, events on these windows
--   aren’t propagated up by the windowing system, but only by GTK+. The
--   practical effect of this is if an event isn’t in the event mask for
--   the descendant window (see <a>widgetAddEvents</a>), it won’t be
--   received by the event box.
--   
--   This problem doesn’t occur for visible event boxes, because in that
--   case, the event box window is actually the ancestor of the descendant
--   windows, not just at the same place on the screen.
--   
--   <i>Since: 2.4</i>
eventBoxSetVisibleWindow :: (HasCallStack, MonadIO m, IsEventBox a) => a -> Bool -> m ()

-- | Cast to <a>DrawingArea</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toDrawingArea :: (MonadIO m, IsDrawingArea o) => o -> m DrawingArea

-- | Creates a new drawing area.
drawingAreaNew :: (HasCallStack, MonadIO m) => m DrawingArea

-- | Cast to <a>CssProvider</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCssProvider :: (MonadIO m, IsCssProvider o) => o -> m CssProvider

-- | Connect a signal handler for the <a>parsingError</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cssProvider #parsingError callback
--   </pre>
onCssProviderParsingError :: (IsCssProvider a, MonadIO m) => a -> ((?self :: a) => CssProviderParsingErrorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>parsingError</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cssProvider #parsingError callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCssProviderParsingError :: (IsCssProvider a, MonadIO m) => a -> ((?self :: a) => CssProviderParsingErrorCallback) -> m SignalHandlerId

-- | Returns a newly created <a>CssProvider</a>.
cssProviderNew :: (HasCallStack, MonadIO m) => m CssProvider

-- | Loads <i><tt>data</tt></i> into <i><tt>cssProvider</tt></i>, and by
--   doing so clears any previously loaded information.
cssProviderLoadFromData :: (HasCallStack, MonadIO m, IsCssProvider a) => a -> ByteString -> m ()

-- | Loads the data contained in <i><tt>path</tt></i> into
--   <i><tt>cssProvider</tt></i>, making it clear any previously loaded
--   information.
cssProviderLoadFromPath :: (HasCallStack, MonadIO m, IsCssProvider a) => a -> Text -> m ()

-- | Loads the data contained in the resource at
--   <i><tt>resourcePath</tt></i> into the <a>CssProvider</a>, clearing any
--   previously loaded information.
--   
--   To track errors while loading CSS, connect to the
--   <a>CssProvider::parsingError</a> signal.
--   
--   <i>Since: 3.16</i>
cssProviderLoadFromResource :: (HasCallStack, MonadIO m, IsCssProvider a) => a -> Text -> m ()

-- | Converts the <i><tt>provider</tt></i> into a string representation in
--   CSS format.
--   
--   Using <a>cssProviderLoadFromData</a> with the return value from this
--   function on a new provider created with <a>cssProviderNew</a> will
--   basically create a duplicate of this <i><tt>provider</tt></i>.
--   
--   <i>Since: 3.2</i>
cssProviderToString :: (HasCallStack, MonadIO m, IsCssProvider a) => a -> m Text

-- | Returns the provider containing the style settings used as a fallback
--   for all widgets.
cssProviderGetDefault :: (HasCallStack, MonadIO m) => m CssProvider

-- | Loads a theme from the usual theme paths
cssProviderGetNamed :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> m CssProvider

-- | Cast to <a>Box</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toBox :: (MonadIO m, IsBox o) => o -> m Box

-- | Get the value of the “<tt>baseline-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> box #baselinePosition
--   </pre>
getBoxBaselinePosition :: (MonadIO m, IsBox o) => o -> m BaselinePosition

-- | Set the value of the “<tt>baseline-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> box [ #baselinePosition <a>:=</a> value ]
--   </pre>
setBoxBaselinePosition :: (MonadIO m, IsBox o) => o -> BaselinePosition -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>baseline-position</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructBoxBaselinePosition :: (IsBox o, MonadIO m) => BaselinePosition -> m (GValueConstruct o)

-- | Get the value of the “<tt>homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> box #homogeneous
--   </pre>
getBoxHomogeneous :: (MonadIO m, IsBox o) => o -> m Bool

-- | Set the value of the “<tt>homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> box [ #homogeneous <a>:=</a> value ]
--   </pre>
setBoxHomogeneous :: (MonadIO m, IsBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>homogeneous</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructBoxHomogeneous :: (IsBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> box #spacing
--   </pre>
getBoxSpacing :: (MonadIO m, IsBox o) => o -> m Int32

-- | Set the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> box [ #spacing <a>:=</a> value ]
--   </pre>
setBoxSpacing :: (MonadIO m, IsBox o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>spacing</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructBoxSpacing :: (IsBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new <a>Box</a>.
--   
--   <i>Since: 3.0</i>
boxNew :: (HasCallStack, MonadIO m) => Orientation -> Int32 -> m Box

-- | Gets the value set by <a>boxSetBaselinePosition</a>.
--   
--   <i>Since: 3.10</i>
boxGetBaselinePosition :: (HasCallStack, MonadIO m, IsBox a) => a -> m BaselinePosition

-- | Retrieves the center widget of the box.
--   
--   <i>Since: 3.12</i>
boxGetCenterWidget :: (HasCallStack, MonadIO m, IsBox a) => a -> m (Maybe Widget)

-- | Returns whether the box is homogeneous (all children are the same
--   size). See <a>boxSetHomogeneous</a>.
boxGetHomogeneous :: (HasCallStack, MonadIO m, IsBox a) => a -> m Bool

-- | Gets the value set by <a>boxSetSpacing</a>.
boxGetSpacing :: (HasCallStack, MonadIO m, IsBox a) => a -> m Int32

-- | Adds <i><tt>child</tt></i> to <i><tt>box</tt></i>, packed with
--   reference to the end of <i><tt>box</tt></i>. The <i><tt>child</tt></i>
--   is packed after (away from end of) any other child packed with
--   reference to the end of <i><tt>box</tt></i>.
boxPackEnd :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> b -> Bool -> Bool -> Word32 -> m ()

-- | Obtains information about how <i><tt>child</tt></i> is packed into
--   <i><tt>box</tt></i>.
boxQueryChildPacking :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> b -> m (Bool, Bool, Word32, PackType)

-- | Moves <i><tt>child</tt></i> to a new <i><tt>position</tt></i> in the
--   list of <i><tt>box</tt></i> children. The list contains widgets packed
--   <tt><i>GTK_PACK_START</i></tt> as well as widgets packed
--   <tt><i>GTK_PACK_END</i></tt>, in the order that these widgets were
--   added to <i><tt>box</tt></i>.
--   
--   A widget’s position in the <i><tt>box</tt></i> children list
--   determines where the widget is packed into <i><tt>box</tt></i>. A
--   child widget at some position in the list will be packed just after
--   all other widgets of the same packing type that appear earlier in the
--   list.
boxReorderChild :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Sets the baseline position of a box. This affects only horizontal
--   boxes with at least one baseline aligned child. If there is more
--   vertical space available than requested, and the baseline is not
--   allocated by the parent then <i><tt>position</tt></i> is used to
--   allocate the baseline wrt the extra space available.
--   
--   <i>Since: 3.10</i>
boxSetBaselinePosition :: (HasCallStack, MonadIO m, IsBox a) => a -> BaselinePosition -> m ()

-- | Sets a center widget; that is a child widget that will be centered
--   with respect to the full width of the box, even if the children at
--   either side take up different amounts of space.
--   
--   <i>Since: 3.12</i>
boxSetCenterWidget :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the way <i><tt>child</tt></i> is packed into <i><tt>box</tt></i>.
boxSetChildPacking :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> b -> Bool -> Bool -> Word32 -> PackType -> m ()

-- | Cast to <a>VBox</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toVBox :: (MonadIO m, IsVBox o) => o -> m VBox

-- | Creates a new <a>VBox</a>.
vBoxNew :: (HasCallStack, MonadIO m) => Bool -> Int32 -> m VBox

-- | Cast to <a>Statusbar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toStatusbar :: (MonadIO m, IsStatusbar o) => o -> m Statusbar

-- | Connect a signal handler for the <a>textPopped</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> statusbar #textPopped callback
--   </pre>
onStatusbarTextPopped :: (IsStatusbar a, MonadIO m) => a -> ((?self :: a) => StatusbarTextPoppedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>textPopped</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> statusbar #textPopped callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterStatusbarTextPopped :: (IsStatusbar a, MonadIO m) => a -> ((?self :: a) => StatusbarTextPoppedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>textPushed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> statusbar #textPushed callback
--   </pre>
onStatusbarTextPushed :: (IsStatusbar a, MonadIO m) => a -> ((?self :: a) => StatusbarTextPushedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>textPushed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> statusbar #textPushed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterStatusbarTextPushed :: (IsStatusbar a, MonadIO m) => a -> ((?self :: a) => StatusbarTextPushedCallback) -> m SignalHandlerId

-- | Creates a new <a>Statusbar</a> ready for messages.
statusbarNew :: (HasCallStack, MonadIO m) => m Statusbar

-- | Returns a new context identifier, given a description of the actual
--   context. Note that the description is not shown in the UI.
statusbarGetContextId :: (HasCallStack, MonadIO m, IsStatusbar a) => a -> Text -> m Word32

-- | Retrieves the box containing the label widget.
--   
--   <i>Since: 2.20</i>
statusbarGetMessageArea :: (HasCallStack, MonadIO m, IsStatusbar a) => a -> m Box

-- | Removes the first message in the <a>Statusbar</a>’s stack with the
--   given context id.
--   
--   Note that this may not change the displayed message, if the message at
--   the top of the stack has a different context id.
statusbarPop :: (HasCallStack, MonadIO m, IsStatusbar a) => a -> Word32 -> m ()

-- | Pushes a new message onto a statusbar’s stack.
statusbarPush :: (HasCallStack, MonadIO m, IsStatusbar a) => a -> Word32 -> Text -> m Word32

-- | Forces the removal of a message from a statusbar’s stack. The exact
--   <i><tt>contextId</tt></i> and <i><tt>messageId</tt></i> must be
--   specified.
statusbarRemove :: (HasCallStack, MonadIO m, IsStatusbar a) => a -> Word32 -> Word32 -> m ()

-- | Forces the removal of all messages from a statusbar's stack with the
--   exact <i><tt>contextId</tt></i>.
--   
--   <i>Since: 2.22</i>
statusbarRemoveAll :: (HasCallStack, MonadIO m, IsStatusbar a) => a -> Word32 -> m ()

-- | Cast to <a>StackSwitcher</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toStackSwitcher :: (MonadIO m, IsStackSwitcher o) => o -> m StackSwitcher

-- | Get the value of the “<tt>icon-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stackSwitcher #iconSize
--   </pre>
getStackSwitcherIconSize :: (MonadIO m, IsStackSwitcher o) => o -> m Int32

-- | Set the value of the “<tt>icon-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stackSwitcher [ #iconSize <a>:=</a> value ]
--   </pre>
setStackSwitcherIconSize :: (MonadIO m, IsStackSwitcher o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-size</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructStackSwitcherIconSize :: (IsStackSwitcher o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>stack</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stackSwitcher #stack
--   </pre>
getStackSwitcherStack :: (MonadIO m, IsStackSwitcher o) => o -> m (Maybe Stack)

-- | Set the value of the “<tt>stack</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stackSwitcher [ #stack <a>:=</a> value ]
--   </pre>
setStackSwitcherStack :: (MonadIO m, IsStackSwitcher o, IsStack a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stack</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStackSwitcherStack :: (IsStackSwitcher o, MonadIO m, IsStack a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>stack</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #stack
--   </pre>
clearStackSwitcherStack :: (MonadIO m, IsStackSwitcher o) => o -> m ()

-- | Create a new <a>StackSwitcher</a>.
--   
--   <i>Since: 3.10</i>
stackSwitcherNew :: (HasCallStack, MonadIO m) => m StackSwitcher

-- | Retrieves the stack. See <a>stackSwitcherSetStack</a>.
--   
--   <i>Since: 3.10</i>
stackSwitcherGetStack :: (HasCallStack, MonadIO m, IsStackSwitcher a) => a -> m (Maybe Stack)

-- | Sets the stack to control.
--   
--   <i>Since: 3.10</i>
stackSwitcherSetStack :: (HasCallStack, MonadIO m, IsStackSwitcher a, IsStack b) => a -> Maybe b -> m ()

-- | Cast to <a>ShortcutsShortcut</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toShortcutsShortcut :: (MonadIO m, IsShortcutsShortcut o) => o -> m ShortcutsShortcut

-- | Set the value of the “<tt>accel-size-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #accelSizeGroup <a>:=</a> value ]
--   </pre>
setShortcutsShortcutAccelSizeGroup :: (MonadIO m, IsShortcutsShortcut o, IsSizeGroup a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-size-group</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructShortcutsShortcutAccelSizeGroup :: (IsShortcutsShortcut o, MonadIO m, IsSizeGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>accel-size-group</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #accelSizeGroup
--   </pre>
clearShortcutsShortcutAccelSizeGroup :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Get the value of the “<tt>accelerator</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #accelerator
--   </pre>
getShortcutsShortcutAccelerator :: (MonadIO m, IsShortcutsShortcut o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>accelerator</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #accelerator <a>:=</a> value ]
--   </pre>
setShortcutsShortcutAccelerator :: (MonadIO m, IsShortcutsShortcut o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accelerator</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructShortcutsShortcutAccelerator :: (IsShortcutsShortcut o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>accelerator</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #accelerator
--   </pre>
clearShortcutsShortcutAccelerator :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Get the value of the “<tt>action-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #actionName
--   </pre>
getShortcutsShortcutActionName :: (MonadIO m, IsShortcutsShortcut o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>action-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #actionName <a>:=</a> value ]
--   </pre>
setShortcutsShortcutActionName :: (MonadIO m, IsShortcutsShortcut o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>action-name</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructShortcutsShortcutActionName :: (IsShortcutsShortcut o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>action-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #actionName
--   </pre>
clearShortcutsShortcutActionName :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Get the value of the “<tt>direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #direction
--   </pre>
getShortcutsShortcutDirection :: (MonadIO m, IsShortcutsShortcut o) => o -> m TextDirection

-- | Set the value of the “<tt>direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #direction <a>:=</a> value ]
--   </pre>
setShortcutsShortcutDirection :: (MonadIO m, IsShortcutsShortcut o) => o -> TextDirection -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>direction</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructShortcutsShortcutDirection :: (IsShortcutsShortcut o, MonadIO m) => TextDirection -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #icon
--   </pre>
getShortcutsShortcutIcon :: (MonadIO m, IsShortcutsShortcut o) => o -> m (Maybe Icon)

-- | Set the value of the “<tt>icon</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #icon <a>:=</a> value ]
--   </pre>
setShortcutsShortcutIcon :: (MonadIO m, IsShortcutsShortcut o, IsIcon a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructShortcutsShortcutIcon :: (IsShortcutsShortcut o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>icon</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #icon
--   </pre>
clearShortcutsShortcutIcon :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Get the value of the “<tt>icon-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #iconSet
--   </pre>
getShortcutsShortcutIconSet :: (MonadIO m, IsShortcutsShortcut o) => o -> m Bool

-- | Set the value of the “<tt>icon-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #iconSet <a>:=</a> value ]
--   </pre>
setShortcutsShortcutIconSet :: (MonadIO m, IsShortcutsShortcut o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructShortcutsShortcutIconSet :: (IsShortcutsShortcut o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>shortcut-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #shortcutType
--   </pre>
getShortcutsShortcutShortcutType :: (MonadIO m, IsShortcutsShortcut o) => o -> m ShortcutType

-- | Set the value of the “<tt>shortcut-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #shortcutType <a>:=</a> value ]
--   </pre>
setShortcutsShortcutShortcutType :: (MonadIO m, IsShortcutsShortcut o) => o -> ShortcutType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>shortcut-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructShortcutsShortcutShortcutType :: (IsShortcutsShortcut o, MonadIO m) => ShortcutType -> m (GValueConstruct o)

-- | Get the value of the “<tt>subtitle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #subtitle
--   </pre>
getShortcutsShortcutSubtitle :: (MonadIO m, IsShortcutsShortcut o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>subtitle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #subtitle <a>:=</a> value ]
--   </pre>
setShortcutsShortcutSubtitle :: (MonadIO m, IsShortcutsShortcut o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>subtitle</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructShortcutsShortcutSubtitle :: (IsShortcutsShortcut o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>subtitle</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #subtitle
--   </pre>
clearShortcutsShortcutSubtitle :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Get the value of the “<tt>subtitle-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #subtitleSet
--   </pre>
getShortcutsShortcutSubtitleSet :: (MonadIO m, IsShortcutsShortcut o) => o -> m Bool

-- | Set the value of the “<tt>subtitle-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #subtitleSet <a>:=</a> value ]
--   </pre>
setShortcutsShortcutSubtitleSet :: (MonadIO m, IsShortcutsShortcut o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>subtitle-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructShortcutsShortcutSubtitleSet :: (IsShortcutsShortcut o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #title
--   </pre>
getShortcutsShortcutTitle :: (MonadIO m, IsShortcutsShortcut o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #title <a>:=</a> value ]
--   </pre>
setShortcutsShortcutTitle :: (MonadIO m, IsShortcutsShortcut o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructShortcutsShortcutTitle :: (IsShortcutsShortcut o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>title</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #title
--   </pre>
clearShortcutsShortcutTitle :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Set the value of the “<tt>title-size-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #titleSizeGroup <a>:=</a> value ]
--   </pre>
setShortcutsShortcutTitleSizeGroup :: (MonadIO m, IsShortcutsShortcut o, IsSizeGroup a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title-size-group</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructShortcutsShortcutTitleSizeGroup :: (IsShortcutsShortcut o, MonadIO m, IsSizeGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>title-size-group</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #titleSizeGroup
--   </pre>
clearShortcutsShortcutTitleSizeGroup :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Cast to <a>ShortcutsSection</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toShortcutsSection :: (MonadIO m, IsShortcutsSection o) => o -> m ShortcutsSection

-- | Connect a signal handler for the <a>changeCurrentPage</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> shortcutsSection #changeCurrentPage callback
--   </pre>
onShortcutsSectionChangeCurrentPage :: (IsShortcutsSection a, MonadIO m) => a -> ((?self :: a) => ShortcutsSectionChangeCurrentPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changeCurrentPage</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> shortcutsSection #changeCurrentPage callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterShortcutsSectionChangeCurrentPage :: (IsShortcutsSection a, MonadIO m) => a -> ((?self :: a) => ShortcutsSectionChangeCurrentPageCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>max-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsSection #maxHeight
--   </pre>
getShortcutsSectionMaxHeight :: (MonadIO m, IsShortcutsSection o) => o -> m Word32

-- | Set the value of the “<tt>max-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsSection [ #maxHeight <a>:=</a> value ]
--   </pre>
setShortcutsSectionMaxHeight :: (MonadIO m, IsShortcutsSection o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-height</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructShortcutsSectionMaxHeight :: (IsShortcutsSection o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>section-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsSection #sectionName
--   </pre>
getShortcutsSectionSectionName :: (MonadIO m, IsShortcutsSection o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>section-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsSection [ #sectionName <a>:=</a> value ]
--   </pre>
setShortcutsSectionSectionName :: (MonadIO m, IsShortcutsSection o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>section-name</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructShortcutsSectionSectionName :: (IsShortcutsSection o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>section-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #sectionName
--   </pre>
clearShortcutsSectionSectionName :: (MonadIO m, IsShortcutsSection o) => o -> m ()

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsSection #title
--   </pre>
getShortcutsSectionTitle :: (MonadIO m, IsShortcutsSection o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsSection [ #title <a>:=</a> value ]
--   </pre>
setShortcutsSectionTitle :: (MonadIO m, IsShortcutsSection o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructShortcutsSectionTitle :: (IsShortcutsSection o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>title</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #title
--   </pre>
clearShortcutsSectionTitle :: (MonadIO m, IsShortcutsSection o) => o -> m ()

-- | Get the value of the “<tt>view-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsSection #viewName
--   </pre>
getShortcutsSectionViewName :: (MonadIO m, IsShortcutsSection o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>view-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsSection [ #viewName <a>:=</a> value ]
--   </pre>
setShortcutsSectionViewName :: (MonadIO m, IsShortcutsSection o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>view-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructShortcutsSectionViewName :: (IsShortcutsSection o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>view-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #viewName
--   </pre>
clearShortcutsSectionViewName :: (MonadIO m, IsShortcutsSection o) => o -> m ()

-- | Cast to <a>ShortcutsGroup</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toShortcutsGroup :: (MonadIO m, IsShortcutsGroup o) => o -> m ShortcutsGroup

-- | Set the value of the “<tt>accel-size-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsGroup [ #accelSizeGroup <a>:=</a> value ]
--   </pre>
setShortcutsGroupAccelSizeGroup :: (MonadIO m, IsShortcutsGroup o, IsSizeGroup a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-size-group</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructShortcutsGroupAccelSizeGroup :: (IsShortcutsGroup o, MonadIO m, IsSizeGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>accel-size-group</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #accelSizeGroup
--   </pre>
clearShortcutsGroupAccelSizeGroup :: (MonadIO m, IsShortcutsGroup o) => o -> m ()

-- | Get the value of the “<tt>height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsGroup #height
--   </pre>
getShortcutsGroupHeight :: (MonadIO m, IsShortcutsGroup o) => o -> m Word32

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsGroup #title
--   </pre>
getShortcutsGroupTitle :: (MonadIO m, IsShortcutsGroup o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsGroup [ #title <a>:=</a> value ]
--   </pre>
setShortcutsGroupTitle :: (MonadIO m, IsShortcutsGroup o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructShortcutsGroupTitle :: (IsShortcutsGroup o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>title</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #title
--   </pre>
clearShortcutsGroupTitle :: (MonadIO m, IsShortcutsGroup o) => o -> m ()

-- | Set the value of the “<tt>title-size-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsGroup [ #titleSizeGroup <a>:=</a> value ]
--   </pre>
setShortcutsGroupTitleSizeGroup :: (MonadIO m, IsShortcutsGroup o, IsSizeGroup a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title-size-group</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructShortcutsGroupTitleSizeGroup :: (IsShortcutsGroup o, MonadIO m, IsSizeGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>title-size-group</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #titleSizeGroup
--   </pre>
clearShortcutsGroupTitleSizeGroup :: (MonadIO m, IsShortcutsGroup o) => o -> m ()

-- | Get the value of the “<tt>view</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsGroup #view
--   </pre>
getShortcutsGroupView :: (MonadIO m, IsShortcutsGroup o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>view</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsGroup [ #view <a>:=</a> value ]
--   </pre>
setShortcutsGroupView :: (MonadIO m, IsShortcutsGroup o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>view</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructShortcutsGroupView :: (IsShortcutsGroup o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>view</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #view
--   </pre>
clearShortcutsGroupView :: (MonadIO m, IsShortcutsGroup o) => o -> m ()

-- | Cast to <a>ShortcutLabel</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toShortcutLabel :: (MonadIO m, IsShortcutLabel o) => o -> m ShortcutLabel

-- | Get the value of the “<tt>accelerator</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutLabel #accelerator
--   </pre>
getShortcutLabelAccelerator :: (MonadIO m, IsShortcutLabel o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>accelerator</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutLabel [ #accelerator <a>:=</a> value ]
--   </pre>
setShortcutLabelAccelerator :: (MonadIO m, IsShortcutLabel o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accelerator</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructShortcutLabelAccelerator :: (IsShortcutLabel o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>disabled-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutLabel #disabledText
--   </pre>
getShortcutLabelDisabledText :: (MonadIO m, IsShortcutLabel o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>disabled-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutLabel [ #disabledText <a>:=</a> value ]
--   </pre>
setShortcutLabelDisabledText :: (MonadIO m, IsShortcutLabel o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>disabled-text</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructShortcutLabelDisabledText :: (IsShortcutLabel o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Creates a new <a>ShortcutLabel</a> with <i><tt>accelerator</tt></i>
--   set.
--   
--   <i>Since: 3.22</i>
shortcutLabelNew :: (HasCallStack, MonadIO m) => Text -> m ShortcutLabel

-- | Retrieves the current accelerator of <i><tt>self</tt></i>.
--   
--   <i>Since: 3.22</i>
shortcutLabelGetAccelerator :: (HasCallStack, MonadIO m, IsShortcutLabel a) => a -> m (Maybe Text)

-- | Retrieves the text that is displayed when no accelerator is set.
--   
--   <i>Since: 3.22</i>
shortcutLabelGetDisabledText :: (HasCallStack, MonadIO m, IsShortcutLabel a) => a -> m (Maybe Text)

-- | Sets the accelerator to be displayed by <i><tt>self</tt></i>.
--   
--   <i>Since: 3.22</i>
shortcutLabelSetAccelerator :: (HasCallStack, MonadIO m, IsShortcutLabel a) => a -> Text -> m ()

-- | Sets the text to be displayed by <i><tt>self</tt></i> when no
--   accelerator is set.
--   
--   <i>Since: 3.22</i>
shortcutLabelSetDisabledText :: (HasCallStack, MonadIO m, IsShortcutLabel a) => a -> Text -> m ()

-- | Cast to <a>HBox</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toHBox :: (MonadIO m, IsHBox o) => o -> m HBox

-- | Creates a new <a>HBox</a>.
hBoxNew :: (HasCallStack, MonadIO m) => Bool -> Int32 -> m HBox

-- | Cast to <a>FontSelection</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFontSelection :: (MonadIO m, IsFontSelection o) => o -> m FontSelection

-- | Get the value of the “<tt>font-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontSelection #fontName
--   </pre>
getFontSelectionFontName :: (MonadIO m, IsFontSelection o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>font-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontSelection [ #fontName <a>:=</a> value ]
--   </pre>
setFontSelectionFontName :: (MonadIO m, IsFontSelection o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontSelectionFontName :: (IsFontSelection o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>font-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #fontName
--   </pre>
clearFontSelectionFontName :: (MonadIO m, IsFontSelection o) => o -> m ()

-- | Get the value of the “<tt>preview-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontSelection #previewText
--   </pre>
getFontSelectionPreviewText :: (MonadIO m, IsFontSelection o) => o -> m Text

-- | Set the value of the “<tt>preview-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontSelection [ #previewText <a>:=</a> value ]
--   </pre>
setFontSelectionPreviewText :: (MonadIO m, IsFontSelection o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>preview-text</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFontSelectionPreviewText :: (IsFontSelection o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Creates a new <a>FontSelection</a>.
fontSelectionNew :: (HasCallStack, MonadIO m) => m FontSelection

-- | Gets the <a>FontFace</a> representing the selected font group details
--   (i.e. family, slant, weight, width, etc).
--   
--   <i>Since: 2.14</i>
fontSelectionGetFace :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m FontFace

-- | This returns the <a>TreeView</a> which lists all styles available for
--   the selected font. For example, “Regular”, “Bold”, etc.
--   
--   <i>Since: 2.14</i>
fontSelectionGetFaceList :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m Widget

-- | Gets the <a>FontFamily</a> representing the selected font family.
--   
--   <i>Since: 2.14</i>
fontSelectionGetFamily :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m FontFamily

-- | This returns the <a>TreeView</a> that lists font families, for
--   example, “Sans”, “Serif”, etc.
--   
--   <i>Since: 2.14</i>
fontSelectionGetFamilyList :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m Widget

-- | Gets the currently-selected font name.
--   
--   Note that this can be a different string than what you set with
--   <a>fontSelectionSetFontName</a>, as the font selection widget may
--   normalize font names and thus return a string with a different
--   structure. For example, “Helvetica Italic Bold 12” could be normalized
--   to “Helvetica Bold Italic 12”. Use <a>fontDescriptionEqual</a> if you
--   want to compare two font descriptions.
fontSelectionGetFontName :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m Text

-- | This returns the <a>Entry</a> used to display the font as a preview.
--   
--   <i>Since: 2.14</i>
fontSelectionGetPreviewEntry :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m Widget

-- | Gets the text displayed in the preview area.
fontSelectionGetPreviewText :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m Text

-- | The selected font size.
--   
--   <i>Since: 2.14</i>
fontSelectionGetSize :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m Int32

-- | This returns the <a>Entry</a> used to allow the user to edit the font
--   number manually instead of selecting it from the list of font sizes.
--   
--   <i>Since: 2.14</i>
fontSelectionGetSizeEntry :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m Widget

-- | This returns the <a>TreeView</a> used to list font sizes.
--   
--   <i>Since: 2.14</i>
fontSelectionGetSizeList :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> m Widget

-- | Sets the currently-selected font.
--   
--   Note that the <i><tt>fontsel</tt></i> needs to know the screen in
--   which it will appear for this to work; this can be guaranteed by
--   simply making sure that the <i><tt>fontsel</tt></i> is inserted in a
--   toplevel window before you call this function.
fontSelectionSetFontName :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> Text -> m Bool

-- | Sets the text displayed in the preview area. The <i><tt>text</tt></i>
--   is used to show how the selected font looks.
fontSelectionSetPreviewText :: (HasCallStack, MonadIO m, IsFontSelection a) => a -> Text -> m ()

-- | Cast to <a>FontChooserWidget</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFontChooserWidget :: (MonadIO m, IsFontChooserWidget o) => o -> m FontChooserWidget

-- | Get the value of the “<tt>tweak-action</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontChooserWidget #tweakAction
--   </pre>
getFontChooserWidgetTweakAction :: (MonadIO m, IsFontChooserWidget o) => o -> m (Maybe Action)

-- | Creates a new <a>FontChooserWidget</a>.
--   
--   <i>Since: 3.2</i>
fontChooserWidgetNew :: (HasCallStack, MonadIO m) => m FontChooserWidget

-- | Cast to <a>Dialog</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toDialog :: (MonadIO m, IsDialog o) => o -> m Dialog

-- | Connect a signal handler for the <a>close</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> dialog #close callback
--   </pre>
onDialogClose :: (IsDialog a, MonadIO m) => a -> ((?self :: a) => DialogCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>close</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dialog #close callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDialogClose :: (IsDialog a, MonadIO m) => a -> ((?self :: a) => DialogCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>response</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> dialog #response callback
--   </pre>
onDialogResponse :: (IsDialog a, MonadIO m) => a -> ((?self :: a) => DialogResponseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>response</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dialog #response callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDialogResponse :: (IsDialog a, MonadIO m) => a -> ((?self :: a) => DialogResponseCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>use-header-bar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dialog #useHeaderBar
--   </pre>
getDialogUseHeaderBar :: (MonadIO m, IsDialog o) => o -> m Int32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-header-bar</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructDialogUseHeaderBar :: (IsDialog o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new dialog box.
--   
--   Widgets should not be packed into this <a>Window</a> directly, but
--   into the <i><tt>vbox</tt></i> and <i><tt>actionArea</tt></i>, as
--   described above.
dialogNew :: (HasCallStack, MonadIO m) => m Dialog

-- | Adds an activatable widget to the action area of a <a>Dialog</a>,
--   connecting a signal handler that will emit the <a>Dialog::response</a>
--   signal on the dialog when the widget is activated. The widget is
--   appended to the end of the dialog’s action area. If you want to add a
--   non-activatable widget, simply pack it into the
--   <i><tt>actionArea</tt></i> field of the <a>Dialog</a> struct.
dialogAddActionWidget :: (HasCallStack, MonadIO m, IsDialog a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Returns the action area of <i><tt>dialog</tt></i>.
--   
--   <i>Since: 2.14</i>
dialogGetActionArea :: (HasCallStack, MonadIO m, IsDialog a) => a -> m Box

-- | Returns the header bar of <i><tt>dialog</tt></i>. Note that the
--   headerbar is only used by the dialog if the <a>Dialog:useHeaderBar</a>
--   property is <a>True</a>.
--   
--   <i>Since: 3.12</i>
dialogGetHeaderBar :: (HasCallStack, MonadIO m, IsDialog a) => a -> m HeaderBar

-- | Gets the response id of a widget in the action area of a dialog.
--   
--   <i>Since: 2.8</i>
dialogGetResponseForWidget :: (HasCallStack, MonadIO m, IsDialog a, IsWidget b) => a -> b -> m Int32

-- | Gets the widget button that uses the given response ID in the action
--   area of a dialog.
--   
--   <i>Since: 2.20</i>
dialogGetWidgetForResponse :: (HasCallStack, MonadIO m, IsDialog a) => a -> Int32 -> m (Maybe Widget)

-- | Blocks in a recursive main loop until the <i><tt>dialog</tt></i>
--   either emits the <a>Dialog::response</a> signal, or is destroyed. If
--   the dialog is destroyed during the call to <a>dialogRun</a>,
--   <a>dialogRun</a> returns <tt><i>GTK_RESPONSE_NONE</i></tt>. Otherwise,
--   it returns the response ID from the <a>response</a> signal emission.
--   
--   Before entering the recursive main loop, <a>dialogRun</a> calls
--   <a>widgetShow</a> on the dialog for you. Note that you still need to
--   show any children of the dialog yourself.
--   
--   During <a>dialogRun</a>, the default behavior of
--   <a>Widget::deleteEvent</a> is disabled; if the dialog receives
--   <a>delete_event</a>, it will not be destroyed as windows usually are,
--   and <a>dialogRun</a> will return
--   <tt><i>GTK_RESPONSE_DELETE_EVENT</i></tt>. Also, during
--   <a>dialogRun</a> the dialog will be modal. You can force
--   <a>dialogRun</a> to return at any time by calling
--   <a>dialogResponse</a> to emit the <a>response</a> signal. Destroying
--   the dialog during <a>dialogRun</a> is a very bad idea, because your
--   post-run code won’t know whether the dialog was destroyed or not.
--   
--   After <a>dialogRun</a> returns, you are responsible for hiding or
--   destroying the dialog if you wish to do so.
--   
--   Typical usage of this function might be:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GtkWidget *dialog = gtk_dialog_new ();
--   // Set up dialog...
--   
--   int result = gtk_dialog_run (GTK_DIALOG (dialog));
--   switch (result)
--     {
--       case GTK_RESPONSE_ACCEPT:
--          // do_application_specific_something ();
--          break;
--       default:
--          // do_nothing_since_dialog_was_cancelled ();
--          break;
--     }
--   gtk_widget_destroy (dialog);
--   </pre>
--   
--   Note that even though the recursive main loop gives the effect of a
--   modal dialog (it prevents the user from interacting with other windows
--   in the same window group while the dialog is run), callbacks such as
--   timeouts, IO channel watches, DND drops, etc, will be triggered during
--   a <a>dialogRun</a> call.
dialogRun :: (HasCallStack, MonadIO m, IsDialog a) => a -> m Int32

-- | Sets an alternative button order. If the
--   <a>Settings:gtkAlternativeButtonOrder</a> setting is set to
--   <a>True</a>, the dialog buttons are reordered according to the order
--   of the response ids in <i><tt>newOrder</tt></i>.
--   
--   See <tt><i>gtk_dialog_set_alternative_button_order()</i></tt> for more
--   information.
--   
--   This function is for use by language bindings.
--   
--   <i>Since: 2.6</i>
dialogSetAlternativeButtonOrderFromArray :: (HasCallStack, MonadIO m, IsDialog a) => a -> [Int32] -> m ()

-- | Sets the last widget in the dialog’s action area with the given
--   <i><tt>responseId</tt></i> as the default widget for the dialog.
--   Pressing “Enter” normally activates the default widget.
dialogSetDefaultResponse :: (HasCallStack, MonadIO m, IsDialog a) => a -> Int32 -> m ()

-- | Calls <tt>gtk_widget_set_sensitive (widget, @setting)</tt> for each
--   widget in the dialog’s action area with the given
--   <i><tt>responseId</tt></i>. A convenient way to sensitize/desensitize
--   dialog buttons.
dialogSetResponseSensitive :: (HasCallStack, MonadIO m, IsDialog a) => a -> Int32 -> Bool -> m ()

-- | Cast to <a>MessageDialog</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMessageDialog :: (MonadIO m, IsMessageDialog o) => o -> m MessageDialog

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>buttons</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMessageDialogButtons :: (IsMessageDialog o, MonadIO m) => ButtonsType -> m (GValueConstruct o)

-- | Get the value of the “<tt>image</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> messageDialog #image
--   </pre>
getMessageDialogImage :: (MonadIO m, IsMessageDialog o) => o -> m Widget

-- | Set the value of the “<tt>image</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> messageDialog [ #image <a>:=</a> value ]
--   </pre>
setMessageDialogImage :: (MonadIO m, IsMessageDialog o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>image</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMessageDialogImage :: (IsMessageDialog o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>message-area</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> messageDialog #messageArea
--   </pre>
getMessageDialogMessageArea :: (MonadIO m, IsMessageDialog o) => o -> m Widget

-- | Get the value of the “<tt>message-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> messageDialog #messageType
--   </pre>
getMessageDialogMessageType :: (MonadIO m, IsMessageDialog o) => o -> m MessageType

-- | Set the value of the “<tt>message-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> messageDialog [ #messageType <a>:=</a> value ]
--   </pre>
setMessageDialogMessageType :: (MonadIO m, IsMessageDialog o) => o -> MessageType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>message-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructMessageDialogMessageType :: (IsMessageDialog o, MonadIO m) => MessageType -> m (GValueConstruct o)

-- | Get the value of the “<tt>secondary-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> messageDialog #secondaryText
--   </pre>
getMessageDialogSecondaryText :: (MonadIO m, IsMessageDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>secondary-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> messageDialog [ #secondaryText <a>:=</a> value ]
--   </pre>
setMessageDialogSecondaryText :: (MonadIO m, IsMessageDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-text</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructMessageDialogSecondaryText :: (IsMessageDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>secondary-text</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #secondaryText
--   </pre>
clearMessageDialogSecondaryText :: (MonadIO m, IsMessageDialog o) => o -> m ()

-- | Get the value of the “<tt>secondary-use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> messageDialog #secondaryUseMarkup
--   </pre>
getMessageDialogSecondaryUseMarkup :: (MonadIO m, IsMessageDialog o) => o -> m Bool

-- | Set the value of the “<tt>secondary-use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> messageDialog [ #secondaryUseMarkup <a>:=</a> value ]
--   </pre>
setMessageDialogSecondaryUseMarkup :: (MonadIO m, IsMessageDialog o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-use-markup</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructMessageDialogSecondaryUseMarkup :: (IsMessageDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> messageDialog #text
--   </pre>
getMessageDialogText :: (MonadIO m, IsMessageDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> messageDialog [ #text <a>:=</a> value ]
--   </pre>
setMessageDialogText :: (MonadIO m, IsMessageDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMessageDialogText :: (IsMessageDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>text</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #text
--   </pre>
clearMessageDialogText :: (MonadIO m, IsMessageDialog o) => o -> m ()

-- | Get the value of the “<tt>use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> messageDialog #useMarkup
--   </pre>
getMessageDialogUseMarkup :: (MonadIO m, IsMessageDialog o) => o -> m Bool

-- | Set the value of the “<tt>use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> messageDialog [ #useMarkup <a>:=</a> value ]
--   </pre>
setMessageDialogUseMarkup :: (MonadIO m, IsMessageDialog o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-markup</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructMessageDialogUseMarkup :: (IsMessageDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Gets the dialog’s image.
--   
--   <i>Since: 2.14</i>
messageDialogGetImage :: (HasCallStack, MonadIO m, IsMessageDialog a) => a -> m Widget

-- | Returns the message area of the dialog. This is the box where the
--   dialog’s primary and secondary labels are packed. You can add your own
--   extra content to that box and it will appear below those labels. See
--   <a>dialogGetContentArea</a> for the corresponding function in the
--   parent <a>Dialog</a>.
--   
--   <i>Since: 2.22</i>
messageDialogGetMessageArea :: (HasCallStack, MonadIO m, IsMessageDialog a) => a -> m Widget

-- | Sets the dialog’s image to <i><tt>image</tt></i>.
--   
--   <i>Since: 2.10</i>
messageDialogSetImage :: (HasCallStack, MonadIO m, IsMessageDialog a, IsWidget b) => a -> b -> m ()

-- | Sets the text of the message dialog to be <i><tt>str</tt></i>, which
--   is marked up with the [Pango text markup language][PangoMarkupFormat].
--   
--   <i>Since: 2.4</i>
messageDialogSetMarkup :: (HasCallStack, MonadIO m, IsMessageDialog a) => a -> Text -> m ()

-- | Cast to <a>FontSelectionDialog</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toFontSelectionDialog :: (MonadIO m, IsFontSelectionDialog o) => o -> m FontSelectionDialog

-- | Creates a new <a>FontSelectionDialog</a>.
fontSelectionDialogNew :: (HasCallStack, MonadIO m) => Text -> m FontSelectionDialog

-- | Gets the “Cancel” button.
--   
--   <i>Since: 2.14</i>
fontSelectionDialogGetCancelButton :: (HasCallStack, MonadIO m, IsFontSelectionDialog a) => a -> m Widget

-- | Gets the currently-selected font name.
--   
--   Note that this can be a different string than what you set with
--   <a>fontSelectionDialogSetFontName</a>, as the font selection widget
--   may normalize font names and thus return a string with a different
--   structure. For example, “Helvetica Italic Bold 12” could be normalized
--   to “Helvetica Bold Italic 12”. Use <a>fontDescriptionEqual</a> if you
--   want to compare two font descriptions.
fontSelectionDialogGetFontName :: (HasCallStack, MonadIO m, IsFontSelectionDialog a) => a -> m Text

-- | Retrieves the <a>FontSelection</a> widget embedded in the dialog.
--   
--   <i>Since: 2.22</i>
fontSelectionDialogGetFontSelection :: (HasCallStack, MonadIO m, IsFontSelectionDialog a) => a -> m Widget

-- | Gets the “OK” button.
--   
--   <i>Since: 2.14</i>
fontSelectionDialogGetOkButton :: (HasCallStack, MonadIO m, IsFontSelectionDialog a) => a -> m Widget

-- | Gets the text displayed in the preview area.
fontSelectionDialogGetPreviewText :: (HasCallStack, MonadIO m, IsFontSelectionDialog a) => a -> m Text

-- | Sets the currently selected font.
fontSelectionDialogSetFontName :: (HasCallStack, MonadIO m, IsFontSelectionDialog a) => a -> Text -> m Bool

-- | Sets the text displayed in the preview area.
fontSelectionDialogSetPreviewText :: (HasCallStack, MonadIO m, IsFontSelectionDialog a) => a -> Text -> m ()

-- | Cast to <a>FontChooserDialog</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFontChooserDialog :: (MonadIO m, IsFontChooserDialog o) => o -> m FontChooserDialog

-- | Creates a new <a>FontChooserDialog</a>.
--   
--   <i>Since: 3.2</i>
fontChooserDialogNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe Text -> Maybe a -> m FontChooserDialog

-- | Cast to <a>ColorSelectionDialog</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toColorSelectionDialog :: (MonadIO m, IsColorSelectionDialog o) => o -> m ColorSelectionDialog

-- | Get the value of the “<tt>cancel-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorSelectionDialog #cancelButton
--   </pre>
getColorSelectionDialogCancelButton :: (MonadIO m, IsColorSelectionDialog o) => o -> m (Maybe Widget)

-- | Get the value of the “<tt>color-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorSelectionDialog #colorSelection
--   </pre>
getColorSelectionDialogColorSelection :: (MonadIO m, IsColorSelectionDialog o) => o -> m Widget

-- | Get the value of the “<tt>help-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorSelectionDialog #helpButton
--   </pre>
getColorSelectionDialogHelpButton :: (MonadIO m, IsColorSelectionDialog o) => o -> m (Maybe Widget)

-- | Get the value of the “<tt>ok-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorSelectionDialog #okButton
--   </pre>
getColorSelectionDialogOkButton :: (MonadIO m, IsColorSelectionDialog o) => o -> m (Maybe Widget)

-- | Creates a new <a>ColorSelectionDialog</a>.
colorSelectionDialogNew :: (HasCallStack, MonadIO m) => Text -> m ColorSelectionDialog

-- | Retrieves the <a>ColorSelection</a> widget embedded in the dialog.
--   
--   <i>Since: 2.14</i>
colorSelectionDialogGetColorSelection :: (HasCallStack, MonadIO m, IsColorSelectionDialog a) => a -> m Widget

-- | Cast to <a>ColorSelection</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toColorSelection :: (MonadIO m, IsColorSelection o) => o -> m ColorSelection

-- | Connect a signal handler for the <a>colorChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> colorSelection #colorChanged callback
--   </pre>
onColorSelectionColorChanged :: (IsColorSelection a, MonadIO m) => a -> ((?self :: a) => ColorSelectionColorChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>colorChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> colorSelection #colorChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterColorSelectionColorChanged :: (IsColorSelection a, MonadIO m) => a -> ((?self :: a) => ColorSelectionColorChangedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>current-alpha</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorSelection #currentAlpha
--   </pre>
getColorSelectionCurrentAlpha :: (MonadIO m, IsColorSelection o) => o -> m Word32

-- | Set the value of the “<tt>current-alpha</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorSelection [ #currentAlpha <a>:=</a> value ]
--   </pre>
setColorSelectionCurrentAlpha :: (MonadIO m, IsColorSelection o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>current-alpha</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructColorSelectionCurrentAlpha :: (IsColorSelection o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>current-color</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorSelection #currentColor
--   </pre>
getColorSelectionCurrentColor :: (MonadIO m, IsColorSelection o) => o -> m (Maybe Color)

-- | Set the value of the “<tt>current-color</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorSelection [ #currentColor <a>:=</a> value ]
--   </pre>
setColorSelectionCurrentColor :: (MonadIO m, IsColorSelection o) => o -> Color -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>current-color</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructColorSelectionCurrentColor :: (IsColorSelection o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Get the value of the “<tt>current-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorSelection #currentRgba
--   </pre>
getColorSelectionCurrentRgba :: (MonadIO m, IsColorSelection o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>current-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorSelection [ #currentRgba <a>:=</a> value ]
--   </pre>
setColorSelectionCurrentRgba :: (MonadIO m, IsColorSelection o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>current-rgba</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructColorSelectionCurrentRgba :: (IsColorSelection o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-opacity-control</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorSelection #hasOpacityControl
--   </pre>
getColorSelectionHasOpacityControl :: (MonadIO m, IsColorSelection o) => o -> m Bool

-- | Set the value of the “<tt>has-opacity-control</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorSelection [ #hasOpacityControl <a>:=</a> value ]
--   </pre>
setColorSelectionHasOpacityControl :: (MonadIO m, IsColorSelection o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-opacity-control</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructColorSelectionHasOpacityControl :: (IsColorSelection o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-palette</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorSelection #hasPalette
--   </pre>
getColorSelectionHasPalette :: (MonadIO m, IsColorSelection o) => o -> m Bool

-- | Set the value of the “<tt>has-palette</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorSelection [ #hasPalette <a>:=</a> value ]
--   </pre>
setColorSelectionHasPalette :: (MonadIO m, IsColorSelection o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-palette</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructColorSelectionHasPalette :: (IsColorSelection o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new GtkColorSelection.
colorSelectionNew :: (HasCallStack, MonadIO m) => m ColorSelection

-- | Returns the current alpha value.
colorSelectionGetCurrentAlpha :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m Word16

-- | Sets <i><tt>color</tt></i> to be the current color in the
--   GtkColorSelection widget.
colorSelectionGetCurrentColor :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m Color

-- | Sets <i><tt>rgba</tt></i> to be the current color in the
--   GtkColorSelection widget.
--   
--   <i>Since: 3.0</i>
colorSelectionGetCurrentRgba :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m RGBA

-- | Determines whether the colorsel has an opacity control.
colorSelectionGetHasOpacityControl :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m Bool

-- | Determines whether the color selector has a color palette.
colorSelectionGetHasPalette :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m Bool

-- | Returns the previous alpha value.
colorSelectionGetPreviousAlpha :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m Word16

-- | Fills <i><tt>color</tt></i> in with the original color value.
colorSelectionGetPreviousColor :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m Color

-- | Fills <i><tt>rgba</tt></i> in with the original color value.
--   
--   <i>Since: 3.0</i>
colorSelectionGetPreviousRgba :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m RGBA

-- | Gets the current state of the <i><tt>colorsel</tt></i>.
colorSelectionIsAdjusting :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> m Bool

-- | Sets the current opacity to be <i><tt>alpha</tt></i>.
--   
--   The first time this is called, it will also set the original opacity
--   to be <i><tt>alpha</tt></i> too.
colorSelectionSetCurrentAlpha :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> Word16 -> m ()

-- | Sets the current color to be <i><tt>color</tt></i>.
--   
--   The first time this is called, it will also set the original color to
--   be <i><tt>color</tt></i> too.
colorSelectionSetCurrentColor :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> Color -> m ()

-- | Sets the current color to be <i><tt>rgba</tt></i>.
--   
--   The first time this is called, it will also set the original color to
--   be <i><tt>rgba</tt></i> too.
--   
--   <i>Since: 3.0</i>
colorSelectionSetCurrentRgba :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> RGBA -> m ()

-- | Sets the <i><tt>colorsel</tt></i> to use or not use opacity.
colorSelectionSetHasOpacityControl :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> Bool -> m ()

-- | Shows and hides the palette based upon the value of
--   <i><tt>hasPalette</tt></i>.
colorSelectionSetHasPalette :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> Bool -> m ()

-- | Sets the “previous” alpha to be <i><tt>alpha</tt></i>.
--   
--   This function should be called with some hesitations, as it might seem
--   confusing to have that alpha change.
colorSelectionSetPreviousAlpha :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> Word16 -> m ()

-- | Sets the “previous” color to be <i><tt>color</tt></i>.
--   
--   This function should be called with some hesitations, as it might seem
--   confusing to have that color change. Calling
--   <a>colorSelectionSetCurrentColor</a> will also set this color the
--   first time it is called.
colorSelectionSetPreviousColor :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> Color -> m ()

-- | Sets the “previous” color to be <i><tt>rgba</tt></i>.
--   
--   This function should be called with some hesitations, as it might seem
--   confusing to have that color change. Calling
--   <a>colorSelectionSetCurrentRgba</a> will also set this color the first
--   time it is called.
--   
--   <i>Since: 3.0</i>
colorSelectionSetPreviousRgba :: (HasCallStack, MonadIO m, IsColorSelection a) => a -> RGBA -> m ()

-- | Parses a color palette string; the string is a colon-separated list of
--   color names readable by <a>colorParse</a>.
colorSelectionPaletteFromString :: (HasCallStack, MonadIO m) => Text -> m (Bool, [Color])

-- | Encodes a palette as a string, useful for persistent storage.
colorSelectionPaletteToString :: (HasCallStack, MonadIO m) => [Color] -> m Text

-- | Cast to <a>ColorChooserWidget</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toColorChooserWidget :: (MonadIO m, IsColorChooserWidget o) => o -> m ColorChooserWidget

-- | Get the value of the “<tt>show-editor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorChooserWidget #showEditor
--   </pre>
getColorChooserWidgetShowEditor :: (MonadIO m, IsColorChooserWidget o) => o -> m Bool

-- | Set the value of the “<tt>show-editor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorChooserWidget [ #showEditor <a>:=</a> value ]
--   </pre>
setColorChooserWidgetShowEditor :: (MonadIO m, IsColorChooserWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-editor</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructColorChooserWidgetShowEditor :: (IsColorChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>ColorChooserWidget</a>.
--   
--   <i>Since: 3.4</i>
colorChooserWidgetNew :: (HasCallStack, MonadIO m) => m ColorChooserWidget

-- | Cast to <a>ColorChooserDialog</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toColorChooserDialog :: (MonadIO m, IsColorChooserDialog o) => o -> m ColorChooserDialog

-- | Get the value of the “<tt>show-editor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorChooserDialog #showEditor
--   </pre>
getColorChooserDialogShowEditor :: (MonadIO m, IsColorChooserDialog o) => o -> m Bool

-- | Set the value of the “<tt>show-editor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorChooserDialog [ #showEditor <a>:=</a> value ]
--   </pre>
setColorChooserDialogShowEditor :: (MonadIO m, IsColorChooserDialog o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-editor</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructColorChooserDialogShowEditor :: (IsColorChooserDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>ColorChooserDialog</a>.
--   
--   <i>Since: 3.4</i>
colorChooserDialogNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe Text -> Maybe a -> m ColorChooserDialog

-- | Cast to <a>ButtonBox</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toButtonBox :: (MonadIO m, IsButtonBox o) => o -> m ButtonBox

-- | Get the value of the “<tt>layout-style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> buttonBox #layoutStyle
--   </pre>
getButtonBoxLayoutStyle :: (MonadIO m, IsButtonBox o) => o -> m ButtonBoxStyle

-- | Set the value of the “<tt>layout-style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> buttonBox [ #layoutStyle <a>:=</a> value ]
--   </pre>
setButtonBoxLayoutStyle :: (MonadIO m, IsButtonBox o) => o -> ButtonBoxStyle -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>layout-style</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructButtonBoxLayoutStyle :: (IsButtonBox o, MonadIO m) => ButtonBoxStyle -> m (GValueConstruct o)

-- | Creates a new <a>ButtonBox</a>.
--   
--   <i>Since: 3.0</i>
buttonBoxNew :: (HasCallStack, MonadIO m) => Orientation -> m ButtonBox

-- | Returns whether the child is exempted from homogenous sizing.
--   
--   <i>Since: 3.2</i>
buttonBoxGetChildNonHomogeneous :: (HasCallStack, MonadIO m, IsButtonBox a, IsWidget b) => a -> b -> m Bool

-- | Returns whether <i><tt>child</tt></i> should appear in a secondary
--   group of children.
--   
--   <i>Since: 2.4</i>
buttonBoxGetChildSecondary :: (HasCallStack, MonadIO m, IsButtonBox a, IsWidget b) => a -> b -> m Bool

-- | Retrieves the method being used to arrange the buttons in a button
--   box.
buttonBoxGetLayout :: (HasCallStack, MonadIO m, IsButtonBox a) => a -> m ButtonBoxStyle

-- | Sets whether the child is exempted from homogeous sizing.
--   
--   <i>Since: 3.2</i>
buttonBoxSetChildNonHomogeneous :: (HasCallStack, MonadIO m, IsButtonBox a, IsWidget b) => a -> b -> Bool -> m ()

-- | Sets whether <i><tt>child</tt></i> should appear in a secondary group
--   of children. A typical use of a secondary child is the help button in
--   a dialog.
--   
--   This group appears after the other children if the style is
--   <a>ButtonBoxStyleStart</a>, <a>ButtonBoxStyleSpread</a> or
--   <a>ButtonBoxStyleEdge</a>, and before the other children if the style
--   is <a>ButtonBoxStyleEnd</a>. For horizontal button boxes, the
--   definition of before/after depends on direction of the widget (see
--   <a>widgetSetDirection</a>). If the style is <a>ButtonBoxStyleStart</a>
--   or <a>ButtonBoxStyleEnd</a>, then the secondary children are aligned
--   at the other end of the button box from the main children. For the
--   other styles, they appear immediately next to the main children.
buttonBoxSetChildSecondary :: (HasCallStack, MonadIO m, IsButtonBox a, IsWidget b) => a -> b -> Bool -> m ()

-- | Changes the way buttons are arranged in their container.
buttonBoxSetLayout :: (HasCallStack, MonadIO m, IsButtonBox a) => a -> ButtonBoxStyle -> m ()

-- | Cast to <a>VButtonBox</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toVButtonBox :: (MonadIO m, IsVButtonBox o) => o -> m VButtonBox

-- | Creates a new vertical button box.
vButtonBoxNew :: (HasCallStack, MonadIO m) => m VButtonBox

-- | Cast to <a>HButtonBox</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toHButtonBox :: (MonadIO m, IsHButtonBox o) => o -> m HButtonBox

-- | Creates a new horizontal button box.
hButtonBoxNew :: (HasCallStack, MonadIO m) => m HButtonBox

-- | Cast to <a>Assistant</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAssistant :: (MonadIO m, IsAssistant o) => o -> m Assistant

-- | Connect a signal handler for the <a>apply</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> assistant #apply callback
--   </pre>
onAssistantApply :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantApplyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>apply</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> assistant #apply callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAssistantApply :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantApplyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cancel</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> assistant #cancel callback
--   </pre>
onAssistantCancel :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantCancelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cancel</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> assistant #cancel callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAssistantCancel :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantCancelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>close</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> assistant #close callback
--   </pre>
onAssistantClose :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>close</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> assistant #close callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAssistantClose :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>escape</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> assistant #escape callback
--   </pre>
onAssistantEscape :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantEscapeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>escape</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> assistant #escape callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAssistantEscape :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantEscapeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>prepare</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> assistant #prepare callback
--   </pre>
onAssistantPrepare :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantPrepareCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>prepare</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> assistant #prepare callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAssistantPrepare :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantPrepareCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>use-header-bar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> assistant #useHeaderBar
--   </pre>
getAssistantUseHeaderBar :: (MonadIO m, IsAssistant o) => o -> m Int32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-header-bar</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAssistantUseHeaderBar :: (IsAssistant o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new <a>Assistant</a>.
--   
--   <i>Since: 2.10</i>
assistantNew :: (HasCallStack, MonadIO m) => m Assistant

-- | Appends a page to the <i><tt>assistant</tt></i>.
--   
--   <i>Since: 2.10</i>
assistantAppendPage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Int32

-- | Returns the page number of the current page.
--   
--   <i>Since: 2.10</i>
assistantGetCurrentPage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m Int32

-- | Returns the number of pages in the <i><tt>assistant</tt></i>
--   
--   <i>Since: 2.10</i>
assistantGetNPages :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m Int32

-- | Returns the child widget contained in page number
--   <i><tt>pageNum</tt></i>.
--   
--   <i>Since: 2.10</i>
assistantGetNthPage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> Int32 -> m (Maybe Widget)

-- | Gets whether <i><tt>page</tt></i> is complete.
--   
--   <i>Since: 2.10</i>
assistantGetPageComplete :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Bool

-- | Gets whether page has padding.
--   
--   <i>Since: 3.18</i>
assistantGetPageHasPadding :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Bool

-- | Gets the header image for <i><tt>page</tt></i>.
--   
--   <i>Since: 2.10</i>
assistantGetPageHeaderImage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Pixbuf

-- | Gets the side image for <i><tt>page</tt></i>.
--   
--   <i>Since: 2.10</i>
assistantGetPageSideImage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Pixbuf

-- | Gets the title for <i><tt>page</tt></i>.
--   
--   <i>Since: 2.10</i>
assistantGetPageTitle :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Text

-- | Gets the page type of <i><tt>page</tt></i>.
--   
--   <i>Since: 2.10</i>
assistantGetPageType :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m AssistantPageType

-- | Inserts a page in the <i><tt>assistant</tt></i> at a given position.
--   
--   <i>Since: 2.10</i>
assistantInsertPage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> Int32 -> m Int32

-- | Navigate to the next page.
--   
--   It is a programming error to call this function when there is no next
--   page.
--   
--   This function is for use when creating pages of the
--   <tt><i>GTK_ASSISTANT_PAGE_CUSTOM</i></tt> type.
--   
--   <i>Since: 3.0</i>
assistantNextPage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m ()

-- | Prepends a page to the <i><tt>assistant</tt></i>.
--   
--   <i>Since: 2.10</i>
assistantPrependPage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Int32

-- | Navigate to the previous visited page.
--   
--   It is a programming error to call this function when no previous page
--   is available.
--   
--   This function is for use when creating pages of the
--   <tt><i>GTK_ASSISTANT_PAGE_CUSTOM</i></tt> type.
--   
--   <i>Since: 3.0</i>
assistantPreviousPage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m ()

-- | Removes a widget from the action area of a <a>Assistant</a>.
--   
--   <i>Since: 2.10</i>
assistantRemoveActionWidget :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m ()

-- | Removes the <i><tt>pageNum</tt></i>’s page from
--   <i><tt>assistant</tt></i>.
--   
--   <i>Since: 3.2</i>
assistantRemovePage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> Int32 -> m ()

-- | Switches the page to <i><tt>pageNum</tt></i>.
--   
--   Note that this will only be necessary in custom buttons, as the
--   <i><tt>assistant</tt></i> flow can be set with
--   <a>assistantSetForwardPageFunc</a>.
--   
--   <i>Since: 2.10</i>
assistantSetCurrentPage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> Int32 -> m ()

-- | Sets whether <i><tt>page</tt></i> contents are complete.
--   
--   This will make <i><tt>assistant</tt></i> update the buttons state to
--   be able to continue the task.
--   
--   <i>Since: 2.10</i>
assistantSetPageComplete :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> Bool -> m ()

-- | Sets whether the assistant is adding padding around the page.
--   
--   <i>Since: 3.18</i>
assistantSetPageHasPadding :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> Bool -> m ()

-- | Sets a header image for <i><tt>page</tt></i>.
--   
--   <i>Since: 2.10</i>
assistantSetPageHeaderImage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b, IsPixbuf c) => a -> b -> Maybe c -> m ()

-- | Sets a side image for <i><tt>page</tt></i>.
--   
--   This image used to be displayed in the side area of the assistant when
--   <i><tt>page</tt></i> is the current page.
--   
--   <i>Since: 2.10</i>
assistantSetPageSideImage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b, IsPixbuf c) => a -> b -> Maybe c -> m ()

-- | Sets a title for <i><tt>page</tt></i>.
--   
--   The title is displayed in the header area of the assistant when
--   <i><tt>page</tt></i> is the current page.
--   
--   <i>Since: 2.10</i>
assistantSetPageTitle :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> Text -> m ()

-- | Sets the page type for <i><tt>page</tt></i>.
--   
--   The page type determines the page behavior in the
--   <i><tt>assistant</tt></i>.
--   
--   <i>Since: 2.10</i>
assistantSetPageType :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> AssistantPageType -> m ()

-- | Forces <i><tt>assistant</tt></i> to recompute the buttons state.
--   
--   GTK+ automatically takes care of this in most situations, e.g. when
--   the user goes to a different page, or when the visibility or
--   completeness of a page changes.
--   
--   One situation where it can be necessary to call this function is when
--   changing a value on the current page affects the future page flow of
--   the assistant.
--   
--   <i>Since: 2.10</i>
assistantUpdateButtonsState :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m ()

-- | Cast to <a>AspectFrame</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAspectFrame :: (MonadIO m, IsAspectFrame o) => o -> m AspectFrame

-- | Get the value of the “<tt>obey-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aspectFrame #obeyChild
--   </pre>
getAspectFrameObeyChild :: (MonadIO m, IsAspectFrame o) => o -> m Bool

-- | Set the value of the “<tt>obey-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aspectFrame [ #obeyChild <a>:=</a> value ]
--   </pre>
setAspectFrameObeyChild :: (MonadIO m, IsAspectFrame o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>obey-child</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructAspectFrameObeyChild :: (IsAspectFrame o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>ratio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aspectFrame #ratio
--   </pre>
getAspectFrameRatio :: (MonadIO m, IsAspectFrame o) => o -> m Float

-- | Set the value of the “<tt>ratio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aspectFrame [ #ratio <a>:=</a> value ]
--   </pre>
setAspectFrameRatio :: (MonadIO m, IsAspectFrame o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ratio</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAspectFrameRatio :: (IsAspectFrame o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aspectFrame #xalign
--   </pre>
getAspectFrameXalign :: (MonadIO m, IsAspectFrame o) => o -> m Float

-- | Set the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aspectFrame [ #xalign <a>:=</a> value ]
--   </pre>
setAspectFrameXalign :: (MonadIO m, IsAspectFrame o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>xalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAspectFrameXalign :: (IsAspectFrame o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aspectFrame #yalign
--   </pre>
getAspectFrameYalign :: (MonadIO m, IsAspectFrame o) => o -> m Float

-- | Set the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aspectFrame [ #yalign <a>:=</a> value ]
--   </pre>
setAspectFrameYalign :: (MonadIO m, IsAspectFrame o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>yalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAspectFrameYalign :: (IsAspectFrame o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Create a new <a>AspectFrame</a>.
aspectFrameNew :: (HasCallStack, MonadIO m) => Maybe Text -> Float -> Float -> Float -> Bool -> m AspectFrame

-- | Set parameters for an existing <a>AspectFrame</a>.
aspectFrameSet :: (HasCallStack, MonadIO m, IsAspectFrame a) => a -> Float -> Float -> Float -> Bool -> m ()

-- | Cast to <a>Arrow</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toArrow :: (MonadIO m, IsArrow o) => o -> m Arrow

-- | Get the value of the “<tt>arrow-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> arrow #arrowType
--   </pre>
getArrowArrowType :: (MonadIO m, IsArrow o) => o -> m ArrowType

-- | Set the value of the “<tt>arrow-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> arrow [ #arrowType <a>:=</a> value ]
--   </pre>
setArrowArrowType :: (MonadIO m, IsArrow o) => o -> ArrowType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>arrow-type</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructArrowArrowType :: (IsArrow o, MonadIO m) => ArrowType -> m (GValueConstruct o)

-- | Get the value of the “<tt>shadow-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> arrow #shadowType
--   </pre>
getArrowShadowType :: (MonadIO m, IsArrow o) => o -> m ShadowType

-- | Set the value of the “<tt>shadow-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> arrow [ #shadowType <a>:=</a> value ]
--   </pre>
setArrowShadowType :: (MonadIO m, IsArrow o) => o -> ShadowType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>shadow-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructArrowShadowType :: (IsArrow o, MonadIO m) => ShadowType -> m (GValueConstruct o)

-- | Creates a new <a>Arrow</a> widget.
arrowNew :: (HasCallStack, MonadIO m) => ArrowType -> ShadowType -> m Arrow

-- | Sets the direction and style of the <a>Arrow</a>,
--   <i><tt>arrow</tt></i>.
arrowSet :: (HasCallStack, MonadIO m, IsArrow a) => a -> ArrowType -> ShadowType -> m ()

-- | Cast to <a>ApplicationWindow</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toApplicationWindow :: (MonadIO m, IsApplicationWindow o) => o -> m ApplicationWindow

-- | Get the value of the “<tt>show-menubar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> applicationWindow #showMenubar
--   </pre>
getApplicationWindowShowMenubar :: (MonadIO m, IsApplicationWindow o) => o -> m Bool

-- | Set the value of the “<tt>show-menubar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> applicationWindow [ #showMenubar <a>:=</a> value ]
--   </pre>
setApplicationWindowShowMenubar :: (MonadIO m, IsApplicationWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-menubar</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructApplicationWindowShowMenubar :: (IsApplicationWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>ApplicationWindow</a>.
--   
--   <i>Since: 3.4</i>
applicationWindowNew :: (HasCallStack, MonadIO m, IsApplication a) => a -> m ApplicationWindow

-- | Gets the <a>ShortcutsWindow</a> that has been set up with a prior call
--   to <a>applicationWindowSetHelpOverlay</a>.
--   
--   <i>Since: 3.20</i>
applicationWindowGetHelpOverlay :: (HasCallStack, MonadIO m, IsApplicationWindow a) => a -> m (Maybe ShortcutsWindow)

-- | Returns whether the window will display a menubar for the app menu and
--   menubar as needed.
--   
--   <i>Since: 3.4</i>
applicationWindowGetShowMenubar :: (HasCallStack, MonadIO m, IsApplicationWindow a) => a -> m Bool

-- | Associates a shortcuts window with the application window, and sets up
--   an action with the name win.show-help-overlay to present it.
--   
--   <i><tt>window</tt></i> takes resposibility for destroying
--   <i><tt>helpOverlay</tt></i>.
--   
--   <i>Since: 3.20</i>
applicationWindowSetHelpOverlay :: (HasCallStack, MonadIO m, IsApplicationWindow a, IsShortcutsWindow b) => a -> Maybe b -> m ()

-- | Sets whether the window will display a menubar for the app menu and
--   menubar as needed.
--   
--   <i>Since: 3.4</i>
applicationWindowSetShowMenubar :: (HasCallStack, MonadIO m, IsApplicationWindow a) => a -> Bool -> m ()

-- | Cast to <a>Alignment</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAlignment :: (MonadIO m, IsAlignment o) => o -> m Alignment

-- | Get the value of the “<tt>bottom-padding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> alignment #bottomPadding
--   </pre>
getAlignmentBottomPadding :: (MonadIO m, IsAlignment o) => o -> m Word32

-- | Set the value of the “<tt>bottom-padding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> alignment [ #bottomPadding <a>:=</a> value ]
--   </pre>
setAlignmentBottomPadding :: (MonadIO m, IsAlignment o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>bottom-padding</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAlignmentBottomPadding :: (IsAlignment o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>left-padding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> alignment #leftPadding
--   </pre>
getAlignmentLeftPadding :: (MonadIO m, IsAlignment o) => o -> m Word32

-- | Set the value of the “<tt>left-padding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> alignment [ #leftPadding <a>:=</a> value ]
--   </pre>
setAlignmentLeftPadding :: (MonadIO m, IsAlignment o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>left-padding</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAlignmentLeftPadding :: (IsAlignment o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>right-padding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> alignment #rightPadding
--   </pre>
getAlignmentRightPadding :: (MonadIO m, IsAlignment o) => o -> m Word32

-- | Set the value of the “<tt>right-padding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> alignment [ #rightPadding <a>:=</a> value ]
--   </pre>
setAlignmentRightPadding :: (MonadIO m, IsAlignment o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>right-padding</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAlignmentRightPadding :: (IsAlignment o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>top-padding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> alignment #topPadding
--   </pre>
getAlignmentTopPadding :: (MonadIO m, IsAlignment o) => o -> m Word32

-- | Set the value of the “<tt>top-padding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> alignment [ #topPadding <a>:=</a> value ]
--   </pre>
setAlignmentTopPadding :: (MonadIO m, IsAlignment o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>top-padding</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAlignmentTopPadding :: (IsAlignment o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> alignment #xalign
--   </pre>
getAlignmentXalign :: (MonadIO m, IsAlignment o) => o -> m Float

-- | Set the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> alignment [ #xalign <a>:=</a> value ]
--   </pre>
setAlignmentXalign :: (MonadIO m, IsAlignment o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>xalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAlignmentXalign :: (IsAlignment o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>xscale</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> alignment #xscale
--   </pre>
getAlignmentXscale :: (MonadIO m, IsAlignment o) => o -> m Float

-- | Set the value of the “<tt>xscale</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> alignment [ #xscale <a>:=</a> value ]
--   </pre>
setAlignmentXscale :: (MonadIO m, IsAlignment o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>xscale</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAlignmentXscale :: (IsAlignment o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> alignment #yalign
--   </pre>
getAlignmentYalign :: (MonadIO m, IsAlignment o) => o -> m Float

-- | Set the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> alignment [ #yalign <a>:=</a> value ]
--   </pre>
setAlignmentYalign :: (MonadIO m, IsAlignment o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>yalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAlignmentYalign :: (IsAlignment o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>yscale</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> alignment #yscale
--   </pre>
getAlignmentYscale :: (MonadIO m, IsAlignment o) => o -> m Float

-- | Set the value of the “<tt>yscale</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> alignment [ #yscale <a>:=</a> value ]
--   </pre>
setAlignmentYscale :: (MonadIO m, IsAlignment o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>yscale</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAlignmentYscale :: (IsAlignment o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Creates a new <a>Alignment</a>.
alignmentNew :: (HasCallStack, MonadIO m) => Float -> Float -> Float -> Float -> m Alignment

-- | Gets the padding on the different sides of the widget. See
--   gtk_alignment_set_padding ().
--   
--   <i>Since: 2.4</i>
alignmentGetPadding :: (HasCallStack, MonadIO m, IsAlignment a) => a -> m (Word32, Word32, Word32, Word32)

-- | Sets the <a>Alignment</a> values.
alignmentSet :: (HasCallStack, MonadIO m, IsAlignment a) => a -> Float -> Float -> Float -> Float -> m ()

-- | Sets the padding on the different sides of the widget. The padding
--   adds blank space to the sides of the widget. For instance, this can be
--   used to indent the child widget towards the right by adding padding on
--   the left.
--   
--   <i>Since: 2.4</i>
alignmentSetPadding :: (HasCallStack, MonadIO m, IsAlignment a) => a -> Word32 -> Word32 -> Word32 -> Word32 -> m ()

-- | Cast to <a>ActionBar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toActionBar :: (MonadIO m, IsActionBar o) => o -> m ActionBar

-- | Creates a new <a>ActionBar</a> widget.
--   
--   <i>Since: 3.12</i>
actionBarNew :: (HasCallStack, MonadIO m) => m ActionBar

-- | Retrieves the center bar widget of the bar.
--   
--   <i>Since: 3.12</i>
actionBarGetCenterWidget :: (HasCallStack, MonadIO m, IsActionBar a) => a -> m (Maybe Widget)

-- | Adds <i><tt>child</tt></i> to <i><tt>actionBar</tt></i>, packed with
--   reference to the end of the <i><tt>actionBar</tt></i>.
--   
--   <i>Since: 3.12</i>
actionBarPackEnd :: (HasCallStack, MonadIO m, IsActionBar a, IsWidget b) => a -> b -> m ()

-- | Adds <i><tt>child</tt></i> to <i><tt>actionBar</tt></i>, packed with
--   reference to the start of the <i><tt>actionBar</tt></i>.
--   
--   <i>Since: 3.12</i>
actionBarPackStart :: (HasCallStack, MonadIO m, IsActionBar a, IsWidget b) => a -> b -> m ()

-- | Sets the center widget for the <a>ActionBar</a>.
--   
--   <i>Since: 3.12</i>
actionBarSetCenterWidget :: (HasCallStack, MonadIO m, IsActionBar a, IsWidget b) => a -> Maybe b -> m ()

-- | Cast to <a>UIManager</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toUIManager :: (MonadIO m, IsUIManager o) => o -> m UIManager

-- | Connect a signal handler for the <a>actionsChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> uIManager #actionsChanged callback
--   </pre>
onUIManagerActionsChanged :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerActionsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>actionsChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> uIManager #actionsChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterUIManagerActionsChanged :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerActionsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>addWidget</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> uIManager #addWidget callback
--   </pre>
onUIManagerAddWidget :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerAddWidgetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>addWidget</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> uIManager #addWidget callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterUIManagerAddWidget :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerAddWidgetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>connectProxy</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> uIManager #connectProxy callback
--   </pre>
onUIManagerConnectProxy :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerConnectProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>connectProxy</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> uIManager #connectProxy callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterUIManagerConnectProxy :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerConnectProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>disconnectProxy</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> uIManager #disconnectProxy callback
--   </pre>
onUIManagerDisconnectProxy :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerDisconnectProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>disconnectProxy</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> uIManager #disconnectProxy callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterUIManagerDisconnectProxy :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerDisconnectProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>postActivate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> uIManager #postActivate callback
--   </pre>
onUIManagerPostActivate :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerPostActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>postActivate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> uIManager #postActivate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterUIManagerPostActivate :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerPostActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preActivate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> uIManager #preActivate callback
--   </pre>
onUIManagerPreActivate :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerPreActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preActivate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> uIManager #preActivate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterUIManagerPreActivate :: (IsUIManager a, MonadIO m) => a -> ((?self :: a) => UIManagerPreActivateCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>add-tearoffs</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> uIManager #addTearoffs
--   </pre>
getUIManagerAddTearoffs :: (MonadIO m, IsUIManager o) => o -> m Bool

-- | Set the value of the “<tt>add-tearoffs</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> uIManager [ #addTearoffs <a>:=</a> value ]
--   </pre>
setUIManagerAddTearoffs :: (MonadIO m, IsUIManager o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>add-tearoffs</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructUIManagerAddTearoffs :: (IsUIManager o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>ui</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> uIManager #ui
--   </pre>
getUIManagerUi :: (MonadIO m, IsUIManager o) => o -> m (Maybe Text)

-- | Creates a new ui manager object.
--   
--   <i>Since: 2.4</i>
uIManagerNew :: (HasCallStack, MonadIO m) => m UIManager

-- | Parses a file containing a [UI definition][XML-UI] and merges it with
--   the current contents of <i><tt>manager</tt></i>.
--   
--   <i>Since: 2.4</i>
uIManagerAddUiFromFile :: (HasCallStack, MonadIO m, IsUIManager a) => a -> [Char] -> m Word32

-- | Parses a resource file containing a [UI definition][XML-UI] and merges
--   it with the current contents of <i><tt>manager</tt></i>.
--   
--   <i>Since: 3.4</i>
uIManagerAddUiFromResource :: (HasCallStack, MonadIO m, IsUIManager a) => a -> Text -> m Word32

-- | Parses a string containing a [UI definition][XML-UI] and merges it
--   with the current contents of <i><tt>manager</tt></i>. An enclosing
--   <tt>&lt;ui&gt;</tt> element is added if it is missing.
--   
--   <i>Since: 2.4</i>
uIManagerAddUiFromString :: (HasCallStack, MonadIO m, IsUIManager a) => a -> Text -> Int64 -> m Word32

-- | Makes sure that all pending updates to the UI have been completed.
--   
--   This may occasionally be necessary, since <a>UIManager</a> updates the
--   UI in an idle function. A typical example where this function is
--   useful is to enforce that the menubar and toolbar have been added to
--   the main window before showing it:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   gtk_container_add (GTK_CONTAINER (window), vbox);
--   g_signal_connect (merge, "add-widget",
--                     G_CALLBACK (add_widget), vbox);
--   gtk_ui_manager_add_ui_from_file (merge, "my-menus");
--   gtk_ui_manager_add_ui_from_file (merge, "my-toolbars");
--   gtk_ui_manager_ensure_update (merge);
--   gtk_widget_show (window);
--   </pre>
--   
--   <i>Since: 2.4</i>
uIManagerEnsureUpdate :: (HasCallStack, MonadIO m, IsUIManager a) => a -> m ()

-- | Returns the <a>AccelGroup</a> associated with <i><tt>manager</tt></i>.
--   
--   <i>Since: 2.4</i>
uIManagerGetAccelGroup :: (HasCallStack, MonadIO m, IsUIManager a) => a -> m AccelGroup

-- | Looks up an action by following a path. See <a>uIManagerGetWidget</a>
--   for more information about paths.
--   
--   <i>Since: 2.4</i>
uIManagerGetAction :: (HasCallStack, MonadIO m, IsUIManager a) => a -> Text -> m (Maybe Action)

-- | Returns the list of action groups associated with
--   <i><tt>manager</tt></i>.
--   
--   <i>Since: 2.4</i>
uIManagerGetActionGroups :: (HasCallStack, MonadIO m, IsUIManager a) => a -> m [ActionGroup]

-- | Returns whether menus generated by this <a>UIManager</a> will have
--   tearoff menu items.
--   
--   <i>Since: 2.4</i>
uIManagerGetAddTearoffs :: (HasCallStack, MonadIO m, IsUIManager a) => a -> m Bool

-- | Obtains a list of all toplevel widgets of the requested types.
--   
--   <i>Since: 2.4</i>
uIManagerGetToplevels :: (HasCallStack, MonadIO m, IsUIManager a) => a -> [UIManagerItemType] -> m [Widget]

-- | Creates a [UI definition][XML-UI] of the merged UI.
--   
--   <i>Since: 2.4</i>
uIManagerGetUi :: (HasCallStack, MonadIO m, IsUIManager a) => a -> m Text

-- | Looks up a widget by following a path. The path consists of the names
--   specified in the XML description of the UI. separated by “/”. Elements
--   which don’t have a name or action attribute in the XML (e.g.
--   <tt>&lt;popup&gt;</tt>) can be addressed by their XML element name
--   (e.g. "popup"). The root element ("/ui") can be omitted in the path.
--   
--   Note that the widget found by following a path that ends in a
--   <tt>&lt;menu&gt;</tt>; element is the menuitem to which the menu is
--   attached, not the menu it manages.
--   
--   Also note that the widgets constructed by a ui manager are not tied to
--   the lifecycle of the ui manager. If you add the widgets returned by
--   this function to some container or explicitly ref them, they will
--   survive the destruction of the ui manager.
--   
--   <i>Since: 2.4</i>
uIManagerGetWidget :: (HasCallStack, MonadIO m, IsUIManager a) => a -> Text -> m (Maybe Widget)

-- | Inserts an action group into the list of action groups associated with
--   <i><tt>manager</tt></i>. Actions in earlier groups hide actions with
--   the same name in later groups.
--   
--   If <i><tt>pos</tt></i> is larger than the number of action groups in
--   <i><tt>manager</tt></i>, or negative, <i><tt>actionGroup</tt></i> will
--   be inserted at the end of the internal list.
--   
--   <i>Since: 2.4</i>
uIManagerInsertActionGroup :: (HasCallStack, MonadIO m, IsUIManager a, IsActionGroup b) => a -> b -> Int32 -> m ()

-- | Returns an unused merge id, suitable for use with
--   <a>uIManagerAddUi</a>.
--   
--   <i>Since: 2.4</i>
uIManagerNewMergeId :: (HasCallStack, MonadIO m, IsUIManager a) => a -> m Word32

-- | Removes an action group from the list of action groups associated with
--   <i><tt>manager</tt></i>.
--   
--   <i>Since: 2.4</i>
uIManagerRemoveActionGroup :: (HasCallStack, MonadIO m, IsUIManager a, IsActionGroup b) => a -> b -> m ()

-- | Unmerges the part of <i><tt>manager</tt></i>'s content identified by
--   <i><tt>mergeId</tt></i>.
--   
--   <i>Since: 2.4</i>
uIManagerRemoveUi :: (HasCallStack, MonadIO m, IsUIManager a) => a -> Word32 -> m ()

-- | Sets the “add_tearoffs” property, which controls whether menus
--   generated by this <a>UIManager</a> will have tearoff menu items.
--   
--   Note that this only affects regular menus. Generated popup menus never
--   have tearoff menu items.
--   
--   <i>Since: 2.4</i>
uIManagerSetAddTearoffs :: (HasCallStack, MonadIO m, IsUIManager a) => a -> Bool -> m ()

-- | Cast to <a>ToggleAction</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toToggleAction :: (MonadIO m, IsToggleAction o) => o -> m ToggleAction

-- | Connect a signal handler for the <a>toggled</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> toggleAction #toggled callback
--   </pre>
onToggleActionToggled :: (IsToggleAction a, MonadIO m) => a -> ((?self :: a) => ToggleActionToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggled</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> toggleAction #toggled callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterToggleActionToggled :: (IsToggleAction a, MonadIO m) => a -> ((?self :: a) => ToggleActionToggledCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toggleAction #active
--   </pre>
getToggleActionActive :: (MonadIO m, IsToggleAction o) => o -> m Bool

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toggleAction [ #active <a>:=</a> value ]
--   </pre>
setToggleActionActive :: (MonadIO m, IsToggleAction o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructToggleActionActive :: (IsToggleAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>draw-as-radio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toggleAction #drawAsRadio
--   </pre>
getToggleActionDrawAsRadio :: (MonadIO m, IsToggleAction o) => o -> m Bool

-- | Set the value of the “<tt>draw-as-radio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toggleAction [ #drawAsRadio <a>:=</a> value ]
--   </pre>
setToggleActionDrawAsRadio :: (MonadIO m, IsToggleAction o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>draw-as-radio</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructToggleActionDrawAsRadio :: (IsToggleAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>ToggleAction</a> object. To add the action to a
--   <a>ActionGroup</a> and set the accelerator for the action, call
--   <a>actionGroupAddActionWithAccel</a>.
--   
--   <i>Since: 2.4</i>
toggleActionNew :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Maybe Text -> m ToggleAction

-- | Returns the checked state of the toggle action.
--   
--   <i>Since: 2.4</i>
toggleActionGetActive :: (HasCallStack, MonadIO m, IsToggleAction a) => a -> m Bool

-- | Returns whether the action should have proxies like a radio action.
--   
--   <i>Since: 2.4</i>
toggleActionGetDrawAsRadio :: (HasCallStack, MonadIO m, IsToggleAction a) => a -> m Bool

-- | Sets the checked state on the toggle action.
--   
--   <i>Since: 2.4</i>
toggleActionSetActive :: (HasCallStack, MonadIO m, IsToggleAction a) => a -> Bool -> m ()

-- | Sets whether the action should have proxies like a radio action.
--   
--   <i>Since: 2.4</i>
toggleActionSetDrawAsRadio :: (HasCallStack, MonadIO m, IsToggleAction a) => a -> Bool -> m ()

-- | Emits the “toggled” signal on the toggle action.
--   
--   <i>Since: 2.4</i>
toggleActionToggled :: (HasCallStack, MonadIO m, IsToggleAction a) => a -> m ()

-- | Cast to <a>RadioAction</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toRadioAction :: (MonadIO m, IsRadioAction o) => o -> m RadioAction

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> radioAction #changed callback
--   </pre>
onRadioActionChanged :: (IsRadioAction a, MonadIO m) => a -> ((?self :: a) => RadioActionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> radioAction #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterRadioActionChanged :: (IsRadioAction a, MonadIO m) => a -> ((?self :: a) => RadioActionChangedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>current-value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> radioAction #currentValue
--   </pre>
getRadioActionCurrentValue :: (MonadIO m, IsRadioAction o) => o -> m Int32

-- | Set the value of the “<tt>current-value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> radioAction [ #currentValue <a>:=</a> value ]
--   </pre>
setRadioActionCurrentValue :: (MonadIO m, IsRadioAction o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>current-value</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructRadioActionCurrentValue :: (IsRadioAction o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Set the value of the “<tt>group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> radioAction [ #group <a>:=</a> value ]
--   </pre>
setRadioActionGroup :: (MonadIO m, IsRadioAction o, IsRadioAction a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>group</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructRadioActionGroup :: (IsRadioAction o, MonadIO m, IsRadioAction a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>group</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #group
--   </pre>
clearRadioActionGroup :: (MonadIO m, IsRadioAction o) => o -> m ()

-- | Get the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> radioAction #value
--   </pre>
getRadioActionValue :: (MonadIO m, IsRadioAction o) => o -> m Int32

-- | Set the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> radioAction [ #value <a>:=</a> value ]
--   </pre>
setRadioActionValue :: (MonadIO m, IsRadioAction o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>value</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructRadioActionValue :: (IsRadioAction o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new <a>RadioAction</a> object. To add the action to a
--   <a>ActionGroup</a> and set the accelerator for the action, call
--   <a>actionGroupAddActionWithAccel</a>.
--   
--   <i>Since: 2.4</i>
radioActionNew :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Maybe Text -> Int32 -> m RadioAction

-- | Obtains the value property of the currently active member of the group
--   to which <i><tt>action</tt></i> belongs.
--   
--   <i>Since: 2.4</i>
radioActionGetCurrentValue :: (HasCallStack, MonadIO m, IsRadioAction a) => a -> m Int32

-- | Returns the list representing the radio group for this object. Note
--   that the returned list is only valid until the next change to the
--   group.
--   
--   A common way to set up a group of radio group is the following:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GSList *group = NULL;
--   GtkRadioAction *action;
--   
--   while ( ...more actions to add... /)
--     {
--        action = gtk_radio_action_new (...);
--        
--        gtk_radio_action_set_group (action, group);
--        group = gtk_radio_action_get_group (action);
--     }
--   </pre>
--   
--   <i>Since: 2.4</i>
radioActionGetGroup :: (HasCallStack, MonadIO m, IsRadioAction a) => a -> m [RadioAction]

-- | Joins a radio action object to the group of another radio action
--   object.
--   
--   Use this in language bindings instead of the
--   <a>radioActionGetGroup</a> and <a>radioActionSetGroup</a> methods
--   
--   A common way to set up a group of radio actions is the following:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GtkRadioAction *action;
--   GtkRadioAction *last_action;
--   
--   while ( ...more actions to add... /)
--     {
--        action = gtk_radio_action_new (...);
--        
--        gtk_radio_action_join_group (action, last_action);
--        last_action = action;
--     }
--   </pre>
--   
--   <i>Since: 3.0</i>
radioActionJoinGroup :: (HasCallStack, MonadIO m, IsRadioAction a, IsRadioAction b) => a -> Maybe b -> m ()

-- | Sets the currently active group member to the member with value
--   property <i><tt>currentValue</tt></i>.
--   
--   <i>Since: 2.10</i>
radioActionSetCurrentValue :: (HasCallStack, MonadIO m, IsRadioAction a) => a -> Int32 -> m ()

-- | Sets the radio group for the radio action object.
--   
--   <i>Since: 2.4</i>
radioActionSetGroup :: (HasCallStack, MonadIO m, IsRadioAction a, IsRadioAction b) => a -> [b] -> m ()

-- | Cast to <a>Accessible</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAccessible :: (MonadIO m, IsAccessible o) => o -> m Accessible

-- | Get the value of the “<tt>widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> accessible #widget
--   </pre>
getAccessibleWidget :: (MonadIO m, IsAccessible o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> accessible [ #widget <a>:=</a> value ]
--   </pre>
setAccessibleWidget :: (MonadIO m, IsAccessible o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>widget</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAccessibleWidget :: (IsAccessible o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>widget</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #widget
--   </pre>
clearAccessibleWidget :: (MonadIO m, IsAccessible o) => o -> m ()

-- | This function specifies the callback function to be called when the
--   widget corresponding to a GtkAccessible is destroyed.
accessibleConnectWidgetDestroyed :: (HasCallStack, MonadIO m, IsAccessible a) => a -> m ()

-- | Gets the <a>Widget</a> corresponding to the <a>Accessible</a>. The
--   returned widget does not have a reference added, so you do not need to
--   unref it.
--   
--   <i>Since: 2.22</i>
accessibleGetWidget :: (HasCallStack, MonadIO m, IsAccessible a) => a -> m (Maybe Widget)

-- | Sets the <a>Widget</a> corresponding to the <a>Accessible</a>.
--   
--   <i><tt>accessible</tt></i> will not hold a reference to
--   <i><tt>widget</tt></i>. It is the caller’s responsibility to ensure
--   that when <i><tt>widget</tt></i> is destroyed, the widget is unset by
--   calling this function again with <i><tt>widget</tt></i> set to
--   <a>Nothing</a>.
--   
--   <i>Since: 2.22</i>
accessibleSetWidget :: (HasCallStack, MonadIO m, IsAccessible a, IsWidget b) => a -> Maybe b -> m ()

-- | Cast to <a>WidgetAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toWidgetAccessible :: (MonadIO m, IsWidgetAccessible o) => o -> m WidgetAccessible

-- | Cast to <a>SwitchAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toSwitchAccessible :: (MonadIO m, IsSwitchAccessible o) => o -> m SwitchAccessible

-- | Cast to <a>SpinnerAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toSpinnerAccessible :: (MonadIO m, IsSpinnerAccessible o) => o -> m SpinnerAccessible

-- | Cast to <a>RangeAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toRangeAccessible :: (MonadIO m, IsRangeAccessible o) => o -> m RangeAccessible

-- | Cast to <a>ScaleAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toScaleAccessible :: (MonadIO m, IsScaleAccessible o) => o -> m ScaleAccessible

-- | Cast to <a>ProgressBarAccessible</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toProgressBarAccessible :: (MonadIO m, IsProgressBarAccessible o) => o -> m ProgressBarAccessible

-- | Cast to <a>LevelBarAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toLevelBarAccessible :: (MonadIO m, IsLevelBarAccessible o) => o -> m LevelBarAccessible

-- | Cast to <a>LabelAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toLabelAccessible :: (MonadIO m, IsLabelAccessible o) => o -> m LabelAccessible

-- | Cast to <a>ImageAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toImageAccessible :: (MonadIO m, IsImageAccessible o) => o -> m ImageAccessible

-- | Cast to <a>EntryAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toEntryAccessible :: (MonadIO m, IsEntryAccessible o) => o -> m EntryAccessible

-- | Cast to <a>SpinButtonAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toSpinButtonAccessible :: (MonadIO m, IsSpinButtonAccessible o) => o -> m SpinButtonAccessible

-- | Cast to <a>ContainerAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toContainerAccessible :: (MonadIO m, IsContainerAccessible o) => o -> m ContainerAccessible

-- | Cast to <a>WindowAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toWindowAccessible :: (MonadIO m, IsWindowAccessible o) => o -> m WindowAccessible

-- | Cast to <a>TextViewAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toTextViewAccessible :: (MonadIO m, IsTextViewAccessible o) => o -> m TextViewAccessible

-- | Cast to <a>StatusbarAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toStatusbarAccessible :: (MonadIO m, IsStatusbarAccessible o) => o -> m StatusbarAccessible

-- | Cast to <a>StackAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toStackAccessible :: (MonadIO m, IsStackAccessible o) => o -> m StackAccessible

-- | Cast to <a>SocketAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toSocketAccessible :: (MonadIO m, IsSocketAccessible o) => o -> m SocketAccessible

-- | <i>No description available in the introspection data.</i>
socketAccessibleEmbed :: (HasCallStack, MonadIO m, IsSocketAccessible a) => a -> Text -> m ()

-- | Cast to <a>ScrolledWindowAccessible</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toScrolledWindowAccessible :: (MonadIO m, IsScrolledWindowAccessible o) => o -> m ScrolledWindowAccessible

-- | Cast to <a>PopoverAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toPopoverAccessible :: (MonadIO m, IsPopoverAccessible o) => o -> m PopoverAccessible

-- | Cast to <a>PlugAccessible</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPlugAccessible :: (MonadIO m, IsPlugAccessible o) => o -> m PlugAccessible

-- | <i>No description available in the introspection data.</i>
plugAccessibleGetId :: (HasCallStack, MonadIO m, IsPlugAccessible a) => a -> m Text

-- | Cast to <a>PanedAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toPanedAccessible :: (MonadIO m, IsPanedAccessible o) => o -> m PanedAccessible

-- | Cast to <a>NotebookAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toNotebookAccessible :: (MonadIO m, IsNotebookAccessible o) => o -> m NotebookAccessible

-- | Cast to <a>NotebookPageAccessible</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toNotebookPageAccessible :: (MonadIO m, IsNotebookPageAccessible o) => o -> m NotebookPageAccessible

-- | <i>No description available in the introspection data.</i>
notebookPageAccessibleNew :: (HasCallStack, MonadIO m, IsNotebookAccessible a, IsWidget b) => a -> b -> m NotebookPageAccessible

-- | <i>No description available in the introspection data.</i>
notebookPageAccessibleInvalidate :: (HasCallStack, MonadIO m, IsNotebookPageAccessible a) => a -> m ()

-- | Cast to <a>MenuShellAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toMenuShellAccessible :: (MonadIO m, IsMenuShellAccessible o) => o -> m MenuShellAccessible

-- | Cast to <a>MenuItemAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toMenuItemAccessible :: (MonadIO m, IsMenuItemAccessible o) => o -> m MenuItemAccessible

-- | Cast to <a>MenuAccessible</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMenuAccessible :: (MonadIO m, IsMenuAccessible o) => o -> m MenuAccessible

-- | Cast to <a>ListBoxRowAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toListBoxRowAccessible :: (MonadIO m, IsListBoxRowAccessible o) => o -> m ListBoxRowAccessible

-- | Cast to <a>ListBoxAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toListBoxAccessible :: (MonadIO m, IsListBoxAccessible o) => o -> m ListBoxAccessible

-- | Cast to <a>IconViewAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toIconViewAccessible :: (MonadIO m, IsIconViewAccessible o) => o -> m IconViewAccessible

-- | Cast to <a>HeaderBarAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toHeaderBarAccessible :: (MonadIO m, IsHeaderBarAccessible o) => o -> m HeaderBarAccessible

-- | Cast to <a>FrameAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFrameAccessible :: (MonadIO m, IsFrameAccessible o) => o -> m FrameAccessible

-- | Cast to <a>FlowBoxChildAccessible</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toFlowBoxChildAccessible :: (MonadIO m, IsFlowBoxChildAccessible o) => o -> m FlowBoxChildAccessible

-- | Cast to <a>FlowBoxAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFlowBoxAccessible :: (MonadIO m, IsFlowBoxAccessible o) => o -> m FlowBoxAccessible

-- | Cast to <a>FileChooserWidgetAccessible</a>, for types for which this
--   is known to be safe. For general casts, use <a>castTo</a>.
toFileChooserWidgetAccessible :: (MonadIO m, IsFileChooserWidgetAccessible o) => o -> m FileChooserWidgetAccessible

-- | Cast to <a>ExpanderAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toExpanderAccessible :: (MonadIO m, IsExpanderAccessible o) => o -> m ExpanderAccessible

-- | Cast to <a>ComboBoxAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toComboBoxAccessible :: (MonadIO m, IsComboBoxAccessible o) => o -> m ComboBoxAccessible

-- | Cast to <a>CheckMenuItemAccessible</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toCheckMenuItemAccessible :: (MonadIO m, IsCheckMenuItemAccessible o) => o -> m CheckMenuItemAccessible

-- | Cast to <a>RadioMenuItemAccessible</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toRadioMenuItemAccessible :: (MonadIO m, IsRadioMenuItemAccessible o) => o -> m RadioMenuItemAccessible

-- | Cast to <a>CellAccessible</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCellAccessible :: (MonadIO m, IsCellAccessible o) => o -> m CellAccessible

-- | Cast to <a>ContainerCellAccessible</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toContainerCellAccessible :: (MonadIO m, IsContainerCellAccessible o) => o -> m ContainerCellAccessible

-- | <i>No description available in the introspection data.</i>
containerCellAccessibleNew :: (HasCallStack, MonadIO m) => m ContainerCellAccessible

-- | <i>No description available in the introspection data.</i>
containerCellAccessibleAddChild :: (HasCallStack, MonadIO m, IsContainerCellAccessible a, IsCellAccessible b) => a -> b -> m ()

-- | Get a list of children.
containerCellAccessibleGetChildren :: (HasCallStack, MonadIO m, IsContainerCellAccessible a) => a -> m [CellAccessible]

-- | <i>No description available in the introspection data.</i>
containerCellAccessibleRemoveChild :: (HasCallStack, MonadIO m, IsContainerCellAccessible a, IsCellAccessible b) => a -> b -> m ()

-- | Cast to <a>ButtonAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toButtonAccessible :: (MonadIO m, IsButtonAccessible o) => o -> m ButtonAccessible

-- | Cast to <a>ToggleButtonAccessible</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toToggleButtonAccessible :: (MonadIO m, IsToggleButtonAccessible o) => o -> m ToggleButtonAccessible

-- | Cast to <a>ScaleButtonAccessible</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toScaleButtonAccessible :: (MonadIO m, IsScaleButtonAccessible o) => o -> m ScaleButtonAccessible

-- | Cast to <a>RadioButtonAccessible</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toRadioButtonAccessible :: (MonadIO m, IsRadioButtonAccessible o) => o -> m RadioButtonAccessible

-- | Cast to <a>MenuButtonAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toMenuButtonAccessible :: (MonadIO m, IsMenuButtonAccessible o) => o -> m MenuButtonAccessible

-- | Cast to <a>LockButtonAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toLockButtonAccessible :: (MonadIO m, IsLockButtonAccessible o) => o -> m LockButtonAccessible

-- | Cast to <a>LinkButtonAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toLinkButtonAccessible :: (MonadIO m, IsLinkButtonAccessible o) => o -> m LinkButtonAccessible

-- | Cast to <a>ArrowAccessible</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toArrowAccessible :: (MonadIO m, IsArrowAccessible o) => o -> m ArrowAccessible

-- | Cast to <a>AboutDialog</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAboutDialog :: (MonadIO m, IsAboutDialog o) => o -> m AboutDialog

-- | Connect a signal handler for the <a>activateLink</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> aboutDialog #activateLink callback
--   </pre>
onAboutDialogActivateLink :: (IsAboutDialog a, MonadIO m) => a -> ((?self :: a) => AboutDialogActivateLinkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateLink</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> aboutDialog #activateLink callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAboutDialogActivateLink :: (IsAboutDialog a, MonadIO m) => a -> ((?self :: a) => AboutDialogActivateLinkCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>artists</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #artists
--   </pre>
getAboutDialogArtists :: (MonadIO m, IsAboutDialog o) => o -> m [Text]

-- | Set the value of the “<tt>artists</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #artists <a>:=</a> value ]
--   </pre>
setAboutDialogArtists :: (MonadIO m, IsAboutDialog o) => o -> [Text] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>artists</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAboutDialogArtists :: (IsAboutDialog o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “<tt>authors</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #authors
--   </pre>
getAboutDialogAuthors :: (MonadIO m, IsAboutDialog o) => o -> m [Text]

-- | Set the value of the “<tt>authors</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #authors <a>:=</a> value ]
--   </pre>
setAboutDialogAuthors :: (MonadIO m, IsAboutDialog o) => o -> [Text] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>authors</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAboutDialogAuthors :: (IsAboutDialog o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “<tt>comments</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #comments
--   </pre>
getAboutDialogComments :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “<tt>comments</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #comments <a>:=</a> value ]
--   </pre>
setAboutDialogComments :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>comments</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructAboutDialogComments :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>comments</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #comments
--   </pre>
clearAboutDialogComments :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Get the value of the “<tt>copyright</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #copyright
--   </pre>
getAboutDialogCopyright :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “<tt>copyright</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #copyright <a>:=</a> value ]
--   </pre>
setAboutDialogCopyright :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>copyright</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructAboutDialogCopyright :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>copyright</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #copyright
--   </pre>
clearAboutDialogCopyright :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Get the value of the “<tt>documenters</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #documenters
--   </pre>
getAboutDialogDocumenters :: (MonadIO m, IsAboutDialog o) => o -> m [Text]

-- | Set the value of the “<tt>documenters</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #documenters <a>:=</a> value ]
--   </pre>
setAboutDialogDocumenters :: (MonadIO m, IsAboutDialog o) => o -> [Text] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>documenters</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAboutDialogDocumenters :: (IsAboutDialog o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “<tt>license</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #license
--   </pre>
getAboutDialogLicense :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “<tt>license</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #license <a>:=</a> value ]
--   </pre>
setAboutDialogLicense :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>license</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAboutDialogLicense :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>license</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #license
--   </pre>
clearAboutDialogLicense :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Get the value of the “<tt>license-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #licenseType
--   </pre>
getAboutDialogLicenseType :: (MonadIO m, IsAboutDialog o) => o -> m License

-- | Set the value of the “<tt>license-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #licenseType <a>:=</a> value ]
--   </pre>
setAboutDialogLicenseType :: (MonadIO m, IsAboutDialog o) => o -> License -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>license-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAboutDialogLicenseType :: (IsAboutDialog o, MonadIO m) => License -> m (GValueConstruct o)

-- | Get the value of the “<tt>logo</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #logo
--   </pre>
getAboutDialogLogo :: (MonadIO m, IsAboutDialog o) => o -> m Pixbuf

-- | Set the value of the “<tt>logo</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #logo <a>:=</a> value ]
--   </pre>
setAboutDialogLogo :: (MonadIO m, IsAboutDialog o, IsPixbuf a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>logo</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAboutDialogLogo :: (IsAboutDialog o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>logo</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #logo
--   </pre>
clearAboutDialogLogo :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Get the value of the “<tt>logo-icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #logoIconName
--   </pre>
getAboutDialogLogoIconName :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “<tt>logo-icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #logoIconName <a>:=</a> value ]
--   </pre>
setAboutDialogLogoIconName :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>logo-icon-name</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAboutDialogLogoIconName :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>logo-icon-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #logoIconName
--   </pre>
clearAboutDialogLogoIconName :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Get the value of the “<tt>program-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #programName
--   </pre>
getAboutDialogProgramName :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “<tt>program-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #programName <a>:=</a> value ]
--   </pre>
setAboutDialogProgramName :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>program-name</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAboutDialogProgramName :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>translator-credits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #translatorCredits
--   </pre>
getAboutDialogTranslatorCredits :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “<tt>translator-credits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #translatorCredits <a>:=</a> value ]
--   </pre>
setAboutDialogTranslatorCredits :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>translator-credits</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructAboutDialogTranslatorCredits :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>translator-credits</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #translatorCredits
--   </pre>
clearAboutDialogTranslatorCredits :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Get the value of the “<tt>version</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #version
--   </pre>
getAboutDialogVersion :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “<tt>version</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #version <a>:=</a> value ]
--   </pre>
setAboutDialogVersion :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>version</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAboutDialogVersion :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>version</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #version
--   </pre>
clearAboutDialogVersion :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Get the value of the “<tt>website</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #website
--   </pre>
getAboutDialogWebsite :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “<tt>website</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #website <a>:=</a> value ]
--   </pre>
setAboutDialogWebsite :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>website</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAboutDialogWebsite :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>website</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #website
--   </pre>
clearAboutDialogWebsite :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Get the value of the “<tt>website-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #websiteLabel
--   </pre>
getAboutDialogWebsiteLabel :: (MonadIO m, IsAboutDialog o) => o -> m Text

-- | Set the value of the “<tt>website-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #websiteLabel <a>:=</a> value ]
--   </pre>
setAboutDialogWebsiteLabel :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>website-label</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAboutDialogWebsiteLabel :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap-license</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #wrapLicense
--   </pre>
getAboutDialogWrapLicense :: (MonadIO m, IsAboutDialog o) => o -> m Bool

-- | Set the value of the “<tt>wrap-license</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #wrapLicense <a>:=</a> value ]
--   </pre>
setAboutDialogWrapLicense :: (MonadIO m, IsAboutDialog o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap-license</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAboutDialogWrapLicense :: (IsAboutDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>AboutDialog</a>.
--   
--   <i>Since: 2.6</i>
aboutDialogNew :: (HasCallStack, MonadIO m) => m AboutDialog

-- | Creates a new section in the Credits page.
--   
--   <i>Since: 3.4</i>
aboutDialogAddCreditSection :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Text -> [Text] -> m ()

-- | Returns the string which are displayed in the artists tab of the
--   secondary credits dialog.
--   
--   <i>Since: 2.6</i>
aboutDialogGetArtists :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m [Text]

-- | Returns the string which are displayed in the authors tab of the
--   secondary credits dialog.
--   
--   <i>Since: 2.6</i>
aboutDialogGetAuthors :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m [Text]

-- | Returns the comments string.
--   
--   <i>Since: 2.6</i>
aboutDialogGetComments :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Returns the copyright string.
--   
--   <i>Since: 2.6</i>
aboutDialogGetCopyright :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Returns the string which are displayed in the documenters tab of the
--   secondary credits dialog.
--   
--   <i>Since: 2.6</i>
aboutDialogGetDocumenters :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m [Text]

-- | Returns the license information.
--   
--   <i>Since: 2.6</i>
aboutDialogGetLicense :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Retrieves the license set using <a>aboutDialogSetLicenseType</a>
--   
--   <i>Since: 3.0</i>
aboutDialogGetLicenseType :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m License

-- | Returns the pixbuf displayed as logo in the about dialog.
--   
--   <i>Since: 2.6</i>
aboutDialogGetLogo :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Pixbuf

-- | Returns the icon name displayed as logo in the about dialog.
--   
--   <i>Since: 2.6</i>
aboutDialogGetLogoIconName :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Returns the program name displayed in the about dialog.
--   
--   <i>Since: 2.12</i>
aboutDialogGetProgramName :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Returns the translator credits string which is displayed in the
--   translators tab of the secondary credits dialog.
--   
--   <i>Since: 2.6</i>
aboutDialogGetTranslatorCredits :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Returns the version string.
--   
--   <i>Since: 2.6</i>
aboutDialogGetVersion :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Returns the website URL.
--   
--   <i>Since: 2.6</i>
aboutDialogGetWebsite :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Returns the label used for the website link.
--   
--   <i>Since: 2.6</i>
aboutDialogGetWebsiteLabel :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Text

-- | Returns whether the license text in <i><tt>about</tt></i> is
--   automatically wrapped.
--   
--   <i>Since: 2.8</i>
aboutDialogGetWrapLicense :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Bool

-- | Sets the strings which are displayed in the artists tab of the
--   secondary credits dialog.
--   
--   <i>Since: 2.6</i>
aboutDialogSetArtists :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> [Text] -> m ()

-- | Sets the strings which are displayed in the authors tab of the
--   secondary credits dialog.
--   
--   <i>Since: 2.6</i>
aboutDialogSetAuthors :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> [Text] -> m ()

-- | Sets the comments string to display in the about dialog. This should
--   be a short string of one or two lines.
--   
--   <i>Since: 2.6</i>
aboutDialogSetComments :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the copyright string to display in the about dialog. This should
--   be a short string of one or two lines.
--   
--   <i>Since: 2.6</i>
aboutDialogSetCopyright :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the strings which are displayed in the documenters tab of the
--   secondary credits dialog.
--   
--   <i>Since: 2.6</i>
aboutDialogSetDocumenters :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> [Text] -> m ()

-- | Sets the license information to be displayed in the secondary license
--   dialog. If <i><tt>license</tt></i> is <a>Nothing</a>, the license
--   button is hidden.
--   
--   <i>Since: 2.6</i>
aboutDialogSetLicense :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the license of the application showing the <i><tt>about</tt></i>
--   dialog from a list of known licenses.
--   
--   This function overrides the license set using
--   <a>aboutDialogSetLicense</a>.
--   
--   <i>Since: 3.0</i>
aboutDialogSetLicenseType :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> License -> m ()

-- | Sets the pixbuf to be displayed as logo in the about dialog. If it is
--   <a>Nothing</a>, the default window icon set with
--   <a>windowSetDefaultIcon</a> will be used.
--   
--   <i>Since: 2.6</i>
aboutDialogSetLogo :: (HasCallStack, MonadIO m, IsAboutDialog a, IsPixbuf b) => a -> Maybe b -> m ()

-- | Sets the pixbuf to be displayed as logo in the about dialog. If it is
--   <a>Nothing</a>, the default window icon set with
--   <a>windowSetDefaultIcon</a> will be used.
--   
--   <i>Since: 2.6</i>
aboutDialogSetLogoIconName :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the name to display in the about dialog. If this is not set, it
--   defaults to <a>getApplicationName</a>.
--   
--   <i>Since: 2.12</i>
aboutDialogSetProgramName :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Text -> m ()

-- | Sets the translator credits string which is displayed in the
--   translators tab of the secondary credits dialog.
--   
--   The intended use for this string is to display the translator of the
--   language which is currently used in the user interface. Using
--   <tt><i>gettext()</i></tt>, a simple way to achieve that is to mark the
--   string for translation:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GtkWidget *about = gtk_about_dialog_new ();
--   gtk_about_dialog_set_translator_credits (GTK_ABOUT_DIALOG (about),
--                                            _("translator-credits"));
--   </pre>
--   
--   It is a good idea to use the customary msgid “translator-credits” for
--   this purpose, since translators will already know the purpose of that
--   msgid, and since <a>AboutDialog</a> will detect if
--   “translator-credits” is untranslated and hide the tab.
--   
--   <i>Since: 2.6</i>
aboutDialogSetTranslatorCredits :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the version string to display in the about dialog.
--   
--   <i>Since: 2.6</i>
aboutDialogSetVersion :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the URL to use for the website link.
--   
--   <i>Since: 2.6</i>
aboutDialogSetWebsite :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the label to be used for the website link.
--   
--   <i>Since: 2.6</i>
aboutDialogSetWebsiteLabel :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Text -> m ()

-- | Sets whether the license text in <i><tt>about</tt></i> is
--   automatically wrapped.
--   
--   <i>Since: 2.8</i>
aboutDialogSetWrapLicense :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Bool -> m ()

-- | Asks the <a>TreeDragSource</a> to delete the row at
--   <i><tt>path</tt></i>, because it was moved somewhere else via
--   drag-and-drop. Returns <a>False</a> if the deletion fails because
--   <i><tt>path</tt></i> no longer exists, or for some model-specific
--   reason. Should robustly handle a <i><tt>path</tt></i> no longer found
--   in the model!
treeDragSourceDragDataDelete :: (HasCallStack, MonadIO m, IsTreeDragSource a) => a -> TreePath -> m Bool

-- | Asks the <a>TreeDragSource</a> to fill in
--   <i><tt>selectionData</tt></i> with a representation of the row at
--   <i><tt>path</tt></i>. <i><tt>selectionData</tt></i>-&gt;target gives
--   the required type of the data. Should robustly handle a
--   <i><tt>path</tt></i> no longer found in the model!
treeDragSourceDragDataGet :: (HasCallStack, MonadIO m, IsTreeDragSource a) => a -> TreePath -> SelectionData -> m Bool

-- | Asks the <a>TreeDragSource</a> whether a particular row can be used as
--   the source of a DND operation. If the source doesn’t implement this
--   interface, the row is assumed draggable.
treeDragSourceRowDraggable :: (HasCallStack, MonadIO m, IsTreeDragSource a) => a -> TreePath -> m Bool

-- | Cast to <a>TreeModelSort</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeModelSort :: (MonadIO m, IsTreeModelSort o) => o -> m TreeModelSort

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeModelSort #model
--   </pre>
getTreeModelSortModel :: (MonadIO m, IsTreeModelSort o) => o -> m TreeModel

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeModelSortModel :: (IsTreeModelSort o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Creates a new <a>TreeModelSort</a>, with <i><tt>childModel</tt></i> as
--   the child model.
treeModelSortNewWithModel :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m TreeModelSort

-- | This function should almost never be called. It clears the
--   <i><tt>treeModelSort</tt></i> of any cached iterators that haven’t
--   been reffed with <a>treeModelRefNode</a>. This might be useful if the
--   child model being sorted is static (and doesn’t change often) and
--   there has been a lot of unreffed access to nodes. As a side effect of
--   this function, all unreffed iters will be invalid.
treeModelSortClearCache :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> m ()

-- | Sets <i><tt>sortIter</tt></i> to point to the row in
--   <i><tt>treeModelSort</tt></i> that corresponds to the row pointed at
--   by <i><tt>childIter</tt></i>. If <i><tt>sortIter</tt></i> was not set,
--   <a>False</a> is returned. Note: a boolean is only returned since 2.14.
treeModelSortConvertChildIterToIter :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreeIter -> m (Bool, TreeIter)

-- | Converts <i><tt>childPath</tt></i> to a path relative to
--   <i><tt>treeModelSort</tt></i>. That is, <i><tt>childPath</tt></i>
--   points to a path in the child model. The returned path will point to
--   the same row in the sorted model. If <i><tt>childPath</tt></i> isn’t a
--   valid path on the child model, then <a>Nothing</a> is returned.
treeModelSortConvertChildPathToPath :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreePath -> m (Maybe TreePath)

-- | Sets <i><tt>childIter</tt></i> to point to the row pointed to by
--   <i><tt>sortedIter</tt></i>.
treeModelSortConvertIterToChildIter :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreeIter -> m TreeIter

-- | Converts <i><tt>sortedPath</tt></i> to a path on the child model of
--   <i><tt>treeModelSort</tt></i>. That is, <i><tt>sortedPath</tt></i>
--   points to a location in <i><tt>treeModelSort</tt></i>. The returned
--   path will point to the same location in the model not being sorted. If
--   <i><tt>sortedPath</tt></i> does not point to a location in the child
--   model, <a>Nothing</a> is returned.
treeModelSortConvertPathToChildPath :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreePath -> m (Maybe TreePath)

-- | Returns the model the <a>TreeModelSort</a> is sorting.
treeModelSortGetModel :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> m TreeModel

-- | <pre>
--   This function is slow. Only use it for debugging and\/or testing
--   purposes.
--   </pre>
--   
--   Checks if the given iter is a valid iter for this
--   <a>TreeModelSort</a>.
--   
--   <i>Since: 2.2</i>
treeModelSortIterIsValid :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreeIter -> m Bool

-- | This resets the default sort function to be in the “unsorted” state.
--   That is, it is in the same order as the child model. It will re-sort
--   the model to be in the same order as the child model only if the
--   <a>TreeModelSort</a> is in “unsorted” state.
treeModelSortResetDefaultSortFunc :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> m ()

-- | Cast to <a>TreeModelFilter</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toTreeModelFilter :: (MonadIO m, IsTreeModelFilter o) => o -> m TreeModelFilter

-- | Get the value of the “<tt>child-model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeModelFilter #childModel
--   </pre>
getTreeModelFilterChildModel :: (MonadIO m, IsTreeModelFilter o) => o -> m (Maybe TreeModel)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child-model</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeModelFilterChildModel :: (IsTreeModelFilter o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>virtual-root</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeModelFilter #virtualRoot
--   </pre>
getTreeModelFilterVirtualRoot :: (MonadIO m, IsTreeModelFilter o) => o -> m (Maybe TreePath)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>virtual-root</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeModelFilterVirtualRoot :: (IsTreeModelFilter o, MonadIO m) => TreePath -> m (GValueConstruct o)

-- | This function should almost never be called. It clears the
--   <i><tt>filter</tt></i> of any cached iterators that haven’t been
--   reffed with <a>treeModelRefNode</a>. This might be useful if the child
--   model being filtered is static (and doesn’t change often) and there
--   has been a lot of unreffed access to nodes. As a side effect of this
--   function, all unreffed iters will be invalid.
--   
--   <i>Since: 2.4</i>
treeModelFilterClearCache :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> m ()

-- | Sets <i><tt>filterIter</tt></i> to point to the row in
--   <i><tt>filter</tt></i> that corresponds to the row pointed at by
--   <i><tt>childIter</tt></i>. If <i><tt>filterIter</tt></i> was not set,
--   <a>False</a> is returned.
--   
--   <i>Since: 2.4</i>
treeModelFilterConvertChildIterToIter :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreeIter -> m (Bool, TreeIter)

-- | Converts <i><tt>childPath</tt></i> to a path relative to
--   <i><tt>filter</tt></i>. That is, <i><tt>childPath</tt></i> points to a
--   path in the child model. The rerturned path will point to the same row
--   in the filtered model. If <i><tt>childPath</tt></i> isn’t a valid path
--   on the child model or points to a row which is not visible in
--   <i><tt>filter</tt></i>, then <a>Nothing</a> is returned.
--   
--   <i>Since: 2.4</i>
treeModelFilterConvertChildPathToPath :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreePath -> m (Maybe TreePath)

-- | Sets <i><tt>childIter</tt></i> to point to the row pointed to by
--   <i><tt>filterIter</tt></i>.
--   
--   <i>Since: 2.4</i>
treeModelFilterConvertIterToChildIter :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreeIter -> m TreeIter

-- | Converts <i><tt>filterPath</tt></i> to a path on the child model of
--   <i><tt>filter</tt></i>. That is, <i><tt>filterPath</tt></i> points to
--   a location in <i><tt>filter</tt></i>. The returned path will point to
--   the same location in the model not being filtered. If
--   <i><tt>filterPath</tt></i> does not point to a location in the child
--   model, <a>Nothing</a> is returned.
--   
--   <i>Since: 2.4</i>
treeModelFilterConvertPathToChildPath :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreePath -> m (Maybe TreePath)

-- | Returns a pointer to the child model of <i><tt>filter</tt></i>.
--   
--   <i>Since: 2.4</i>
treeModelFilterGetModel :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> m TreeModel

-- | Emits <a>row_changed</a> for each row in the child model, which causes
--   the filter to re-evaluate whether a row is visible or not.
--   
--   <i>Since: 2.4</i>
treeModelFilterRefilter :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> m ()

-- | Sets <i><tt>column</tt></i> of the child_model to be the column where
--   <i><tt>filter</tt></i> should look for visibility information.
--   <i><tt>columns</tt></i> should be a column of type
--   <tt><i>G_TYPE_BOOLEAN</i></tt>, where <a>True</a> means that a row is
--   visible, and <a>False</a> if not.
--   
--   Note that <a>treeModelFilterSetVisibleFunc</a> or
--   <a>treeModelFilterSetVisibleColumn</a> can only be called once for a
--   given filter model.
--   
--   <i>Since: 2.4</i>
treeModelFilterSetVisibleColumn :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> Int32 -> m ()

-- | Asks the <a>TreeDragDest</a> to insert a row before the path
--   <i><tt>dest</tt></i>, deriving the contents of the row from
--   <i><tt>selectionData</tt></i>. If <i><tt>dest</tt></i> is outside the
--   tree so that inserting before it is impossible, <a>False</a> will be
--   returned. Also, <a>False</a> may be returned if the new row is not
--   created for some model-specific reason. Should robustly handle a
--   <i><tt>dest</tt></i> no longer found in the model!
treeDragDestDragDataReceived :: (HasCallStack, MonadIO m, IsTreeDragDest a) => a -> TreePath -> SelectionData -> m Bool

-- | Determines whether a drop is possible before the given
--   <i><tt>destPath</tt></i>, at the same depth as
--   <i><tt>destPath</tt></i>. i.e., can we drop the data in
--   <i><tt>selectionData</tt></i> at that location.
--   <i><tt>destPath</tt></i> does not have to exist; the return value will
--   almost certainly be <a>False</a> if the parent of
--   <i><tt>destPath</tt></i> doesn’t exist, though.
treeDragDestRowDropPossible :: (HasCallStack, MonadIO m, IsTreeDragDest a) => a -> TreePath -> SelectionData -> m Bool

-- | Cast to <a>TreeStore</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeStore :: (MonadIO m, IsTreeStore o) => o -> m TreeStore

-- | Non vararg creation function. Used primarily by language bindings.
treeStoreNew :: (HasCallStack, MonadIO m) => [GType] -> m TreeStore

-- | Appends a new row to <i><tt>treeStore</tt></i>. If
--   <i><tt>parent</tt></i> is non-<a>Nothing</a>, then it will append the
--   new row after the last child of <i><tt>parent</tt></i>, otherwise it
--   will append a row to the top level. <i><tt>iter</tt></i> will be
--   changed to point to this new row. The row will be empty after this
--   function is called. To fill in values, you need to call
--   <tt><i>gtk_tree_store_set()</i></tt> or <a>treeStoreSetValue</a>.
treeStoreAppend :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> m TreeIter

-- | Removes all rows from <i><tt>treeStore</tt></i>
treeStoreClear :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> m ()

-- | Creates a new row at <i><tt>position</tt></i>. If parent is
--   non-<a>Nothing</a>, then the row will be made a child of
--   <i><tt>parent</tt></i>. Otherwise, the row will be created at the
--   toplevel. If <i><tt>position</tt></i> is -1 or is larger than the
--   number of rows at that level, then the new row will be inserted to the
--   end of the list. <i><tt>iter</tt></i> will be changed to point to this
--   new row. The row will be empty after this function is called. To fill
--   in values, you need to call <tt><i>gtk_tree_store_set()</i></tt> or
--   <a>treeStoreSetValue</a>.
treeStoreInsert :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> Int32 -> m TreeIter

-- | Inserts a new row after <i><tt>sibling</tt></i>. If
--   <i><tt>sibling</tt></i> is <a>Nothing</a>, then the row will be
--   prepended to <i><tt>parent</tt></i> ’s children. If
--   <i><tt>parent</tt></i> and <i><tt>sibling</tt></i> are <a>Nothing</a>,
--   then the row will be prepended to the toplevel. If both
--   <i><tt>sibling</tt></i> and <i><tt>parent</tt></i> are set, then
--   <i><tt>parent</tt></i> must be the parent of <i><tt>sibling</tt></i>.
--   When <i><tt>sibling</tt></i> is set, <i><tt>parent</tt></i> is
--   optional.
--   
--   <i><tt>iter</tt></i> will be changed to point to this new row. The row
--   will be empty after this function is called. To fill in values, you
--   need to call <tt><i>gtk_tree_store_set()</i></tt> or
--   <a>treeStoreSetValue</a>.
treeStoreInsertAfter :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> Maybe TreeIter -> m TreeIter

-- | Inserts a new row before <i><tt>sibling</tt></i>. If
--   <i><tt>sibling</tt></i> is <a>Nothing</a>, then the row will be
--   appended to <i><tt>parent</tt></i> ’s children. If
--   <i><tt>parent</tt></i> and <i><tt>sibling</tt></i> are <a>Nothing</a>,
--   then the row will be appended to the toplevel. If both
--   <i><tt>sibling</tt></i> and <i><tt>parent</tt></i> are set, then
--   <i><tt>parent</tt></i> must be the parent of <i><tt>sibling</tt></i>.
--   When <i><tt>sibling</tt></i> is set, <i><tt>parent</tt></i> is
--   optional.
--   
--   <i><tt>iter</tt></i> will be changed to point to this new row. The row
--   will be empty after this function is called. To fill in values, you
--   need to call <tt><i>gtk_tree_store_set()</i></tt> or
--   <a>treeStoreSetValue</a>.
treeStoreInsertBefore :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> Maybe TreeIter -> m TreeIter

-- | A variant of <tt><i>gtk_tree_store_insert_with_values()</i></tt> which
--   takes the columns and values as two arrays, instead of varargs. This
--   function is mainly intended for language bindings.
--   
--   <i>Since: 2.10</i>
treeStoreInsertWithValues :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> Int32 -> [Int32] -> [GValue] -> m TreeIter

-- | Returns <a>True</a> if <i><tt>iter</tt></i> is an ancestor of
--   <i><tt>descendant</tt></i>. That is, <i><tt>iter</tt></i> is the
--   parent (or grandparent or great-grandparent) of
--   <i><tt>descendant</tt></i>.
treeStoreIsAncestor :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> TreeIter -> m Bool

-- | Returns the depth of <i><tt>iter</tt></i>. This will be 0 for anything
--   on the root level, 1 for anything down a level, etc.
treeStoreIterDepth :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> m Int32

-- | WARNING: This function is slow. Only use it for debugging and/or
--   testing purposes.
--   
--   Checks if the given iter is a valid iter for this <a>TreeStore</a>.
--   
--   <i>Since: 2.2</i>
treeStoreIterIsValid :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> m Bool

-- | Moves <i><tt>iter</tt></i> in <i><tt>treeStore</tt></i> to the
--   position after <i><tt>position</tt></i>. <i><tt>iter</tt></i> and
--   <i><tt>position</tt></i> should be in the same level. Note that this
--   function only works with unsorted stores. If <i><tt>position</tt></i>
--   is <a>Nothing</a>, <i><tt>iter</tt></i> will be moved to the start of
--   the level.
--   
--   <i>Since: 2.2</i>
treeStoreMoveAfter :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> Maybe TreeIter -> m ()

-- | Moves <i><tt>iter</tt></i> in <i><tt>treeStore</tt></i> to the
--   position before <i><tt>position</tt></i>. <i><tt>iter</tt></i> and
--   <i><tt>position</tt></i> should be in the same level. Note that this
--   function only works with unsorted stores. If <i><tt>position</tt></i>
--   is <a>Nothing</a>, <i><tt>iter</tt></i> will be moved to the end of
--   the level.
--   
--   <i>Since: 2.2</i>
treeStoreMoveBefore :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> Maybe TreeIter -> m ()

-- | Prepends a new row to <i><tt>treeStore</tt></i>. If
--   <i><tt>parent</tt></i> is non-<a>Nothing</a>, then it will prepend the
--   new row before the first child of <i><tt>parent</tt></i>, otherwise it
--   will prepend a row to the top level. <i><tt>iter</tt></i> will be
--   changed to point to this new row. The row will be empty after this
--   function is called. To fill in values, you need to call
--   <tt><i>gtk_tree_store_set()</i></tt> or <a>treeStoreSetValue</a>.
treeStorePrepend :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> m TreeIter

-- | Removes <i><tt>iter</tt></i> from <i><tt>treeStore</tt></i>. After
--   being removed, <i><tt>iter</tt></i> is set to the next valid row at
--   that level, or invalidated if it previously pointed to the last one.
treeStoreRemove :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> m Bool

-- | This function is meant primarily for <tt><i>GObjects</i></tt> that
--   inherit from <a>TreeStore</a>, and should only be used when
--   constructing a new <a>TreeStore</a>. It will not function after a row
--   has been added, or a method on the <a>TreeModel</a> interface is
--   called.
treeStoreSetColumnTypes :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> [GType] -> m ()

-- | Sets the data in the cell specified by <i><tt>iter</tt></i> and
--   <i><tt>column</tt></i>. The type of <i><tt>value</tt></i> must be
--   convertible to the type of the column.
treeStoreSetValue :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> Int32 -> GValue -> m ()

-- | A variant of <tt><i>gtk_tree_store_set_valist()</i></tt> which takes
--   the columns and values as two arrays, instead of varargs. This
--   function is mainly intended for language bindings or in case the
--   number of columns to change is not known until run-time.
--   
--   <i>Since: 2.12</i>
treeStoreSet :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> [Int32] -> [GValue] -> m ()

-- | Swaps <i><tt>a</tt></i> and <i><tt>b</tt></i> in the same level of
--   <i><tt>treeStore</tt></i>. Note that this function only works with
--   unsorted stores.
--   
--   <i>Since: 2.2</i>
treeStoreSwap :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> TreeIter -> m ()

-- | Cast to <a>ListStore</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toListStore :: (MonadIO m, IsListStore o) => o -> m ListStore

-- | Non-vararg creation function. Used primarily by language bindings.
listStoreNew :: (HasCallStack, MonadIO m) => [GType] -> m ListStore

-- | Appends a new row to <i><tt>listStore</tt></i>. <i><tt>iter</tt></i>
--   will be changed to point to this new row. The row will be empty after
--   this function is called. To fill in values, you need to call
--   <tt><i>gtk_list_store_set()</i></tt> or <a>listStoreSetValue</a>.
listStoreAppend :: (HasCallStack, MonadIO m, IsListStore a) => a -> m TreeIter

-- | Removes all rows from the list store.
listStoreClear :: (HasCallStack, MonadIO m, IsListStore a) => a -> m ()

-- | Creates a new row at <i><tt>position</tt></i>. <i><tt>iter</tt></i>
--   will be changed to point to this new row. If <i><tt>position</tt></i>
--   is -1 or is larger than the number of rows on the list, then the new
--   row will be appended to the list. The row will be empty after this
--   function is called. To fill in values, you need to call
--   <tt><i>gtk_list_store_set()</i></tt> or <a>listStoreSetValue</a>.
listStoreInsert :: (HasCallStack, MonadIO m, IsListStore a) => a -> Int32 -> m TreeIter

-- | Inserts a new row after <i><tt>sibling</tt></i>. If
--   <i><tt>sibling</tt></i> is <a>Nothing</a>, then the row will be
--   prepended to the beginning of the list. <i><tt>iter</tt></i> will be
--   changed to point to this new row. The row will be empty after this
--   function is called. To fill in values, you need to call
--   <tt><i>gtk_list_store_set()</i></tt> or <a>listStoreSetValue</a>.
listStoreInsertAfter :: (HasCallStack, MonadIO m, IsListStore a) => a -> Maybe TreeIter -> m TreeIter

-- | Inserts a new row before <i><tt>sibling</tt></i>. If
--   <i><tt>sibling</tt></i> is <a>Nothing</a>, then the row will be
--   appended to the end of the list. <i><tt>iter</tt></i> will be changed
--   to point to this new row. The row will be empty after this function is
--   called. To fill in values, you need to call
--   <tt><i>gtk_list_store_set()</i></tt> or <a>listStoreSetValue</a>.
listStoreInsertBefore :: (HasCallStack, MonadIO m, IsListStore a) => a -> Maybe TreeIter -> m TreeIter

-- | A variant of <tt><i>gtk_list_store_insert_with_values()</i></tt> which
--   takes the columns and values as two arrays, instead of varargs. This
--   function is mainly intended for language-bindings.
--   
--   <i>Since: 2.6</i>
listStoreInsertWithValuesv :: (HasCallStack, MonadIO m, IsListStore a) => a -> Int32 -> [Int32] -> [GValue] -> m TreeIter

-- | <pre>
--   This function is slow. Only use it for debugging and\/or testing
--   purposes.
--   </pre>
--   
--   Checks if the given iter is a valid iter for this <a>ListStore</a>.
--   
--   <i>Since: 2.2</i>
listStoreIterIsValid :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> m Bool

-- | Moves <i><tt>iter</tt></i> in <i><tt>store</tt></i> to the position
--   after <i><tt>position</tt></i>. Note that this function only works
--   with unsorted stores. If <i><tt>position</tt></i> is <a>Nothing</a>,
--   <i><tt>iter</tt></i> will be moved to the start of the list.
--   
--   <i>Since: 2.2</i>
listStoreMoveAfter :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> Maybe TreeIter -> m ()

-- | Moves <i><tt>iter</tt></i> in <i><tt>store</tt></i> to the position
--   before <i><tt>position</tt></i>. Note that this function only works
--   with unsorted stores. If <i><tt>position</tt></i> is <a>Nothing</a>,
--   <i><tt>iter</tt></i> will be moved to the end of the list.
--   
--   <i>Since: 2.2</i>
listStoreMoveBefore :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> Maybe TreeIter -> m ()

-- | Prepends a new row to <i><tt>listStore</tt></i>. <i><tt>iter</tt></i>
--   will be changed to point to this new row. The row will be empty after
--   this function is called. To fill in values, you need to call
--   <tt><i>gtk_list_store_set()</i></tt> or <a>listStoreSetValue</a>.
listStorePrepend :: (HasCallStack, MonadIO m, IsListStore a) => a -> m TreeIter

-- | Removes the given row from the list store. After being removed,
--   <i><tt>iter</tt></i> is set to be the next valid row, or invalidated
--   if it pointed to the last row in <i><tt>listStore</tt></i>.
listStoreRemove :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> m Bool

-- | Reorders <i><tt>store</tt></i> to follow the order indicated by
--   <i><tt>newOrder</tt></i>. Note that this function only works with
--   unsorted stores.
--   
--   <i>Since: 2.2</i>
listStoreReorder :: (HasCallStack, MonadIO m, IsListStore a) => a -> [Int32] -> m ()

-- | This function is meant primarily for <tt><i>GObjects</i></tt> that
--   inherit from <a>ListStore</a>, and should only be used when
--   constructing a new <a>ListStore</a>. It will not function after a row
--   has been added, or a method on the <a>TreeModel</a> interface is
--   called.
listStoreSetColumnTypes :: (HasCallStack, MonadIO m, IsListStore a) => a -> [GType] -> m ()

-- | Sets the data in the cell specified by <i><tt>iter</tt></i> and
--   <i><tt>column</tt></i>. The type of <i><tt>value</tt></i> must be
--   convertible to the type of the column.
listStoreSetValue :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> Int32 -> GValue -> m ()

-- | A variant of <tt><i>gtk_list_store_set_valist()</i></tt> which takes
--   the columns and values as two arrays, instead of varargs. This
--   function is mainly intended for language-bindings and in case the
--   number of columns to change is not known until run-time.
--   
--   <i>Since: 2.12</i>
listStoreSet :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> [Int32] -> [GValue] -> m ()

-- | Swaps <i><tt>a</tt></i> and <i><tt>b</tt></i> in
--   <i><tt>store</tt></i>. Note that this function only works with
--   unsorted stores.
--   
--   <i>Since: 2.2</i>
listStoreSwap :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> TreeIter -> m ()

-- | Cast to <a>ToolShell</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toToolShell :: (MonadIO m, IsToolShell o) => o -> m ToolShell

-- | Retrieves the current ellipsize mode for the tool shell. Tool items
--   must not call this function directly, but rely on
--   <a>toolItemGetEllipsizeMode</a> instead.
--   
--   <i>Since: 2.20</i>
toolShellGetEllipsizeMode :: (HasCallStack, MonadIO m, IsToolShell a) => a -> m EllipsizeMode

-- | Retrieves the current text alignment for the tool shell. Tool items
--   must not call this function directly, but rely on
--   <a>toolItemGetTextAlignment</a> instead.
--   
--   <i>Since: 2.20</i>
toolShellGetTextAlignment :: (HasCallStack, MonadIO m, IsToolShell a) => a -> m Float

-- | Retrieves the current text orientation for the tool shell. Tool items
--   must not call this function directly, but rely on
--   <a>toolItemGetTextOrientation</a> instead.
--   
--   <i>Since: 2.20</i>
toolShellGetTextOrientation :: (HasCallStack, MonadIO m, IsToolShell a) => a -> m Orientation

-- | Retrieves the current text size group for the tool shell. Tool items
--   must not call this function directly, but rely on
--   <a>toolItemGetTextSizeGroup</a> instead.
--   
--   <i>Since: 2.20</i>
toolShellGetTextSizeGroup :: (HasCallStack, MonadIO m, IsToolShell a) => a -> m SizeGroup

-- | Calling this function signals the tool shell that the overflow menu
--   item for tool items have changed. If there is an overflow menu and if
--   it is visible when this function it called, the menu will be rebuilt.
--   
--   Tool items must not call this function directly, but rely on
--   <a>toolItemRebuildMenu</a> instead.
--   
--   <i>Since: 2.14</i>
toolShellRebuildMenu :: (HasCallStack, MonadIO m, IsToolShell a) => a -> m ()

-- | Cast to <a>RecentChooser</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toRecentChooser :: (MonadIO m, IsRecentChooser o) => o -> m RecentChooser

-- | Get the value of the “<tt>filter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentChooser #filter
--   </pre>
getRecentChooserFilter :: (MonadIO m, IsRecentChooser o) => o -> m RecentFilter

-- | Set the value of the “<tt>filter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentChooser [ #filter <a>:=</a> value ]
--   </pre>
setRecentChooserFilter :: (MonadIO m, IsRecentChooser o, IsRecentFilter a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>filter</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructRecentChooserFilter :: (IsRecentChooser o, MonadIO m, IsRecentFilter a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>filter</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #filter
--   </pre>
clearRecentChooserFilter :: (MonadIO m, IsRecentChooser o) => o -> m ()

-- | Get the value of the “<tt>limit</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentChooser #limit
--   </pre>
getRecentChooserLimit :: (MonadIO m, IsRecentChooser o) => o -> m Int32

-- | Set the value of the “<tt>limit</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentChooser [ #limit <a>:=</a> value ]
--   </pre>
setRecentChooserLimit :: (MonadIO m, IsRecentChooser o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>limit</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructRecentChooserLimit :: (IsRecentChooser o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>local-only</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentChooser #localOnly
--   </pre>
getRecentChooserLocalOnly :: (MonadIO m, IsRecentChooser o) => o -> m Bool

-- | Set the value of the “<tt>local-only</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentChooser [ #localOnly <a>:=</a> value ]
--   </pre>
setRecentChooserLocalOnly :: (MonadIO m, IsRecentChooser o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>local-only</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructRecentChooserLocalOnly :: (IsRecentChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>recent-manager</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructRecentChooserRecentManager :: (IsRecentChooser o, MonadIO m, IsRecentManager a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>select-multiple</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentChooser #selectMultiple
--   </pre>
getRecentChooserSelectMultiple :: (MonadIO m, IsRecentChooser o) => o -> m Bool

-- | Set the value of the “<tt>select-multiple</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentChooser [ #selectMultiple <a>:=</a> value ]
--   </pre>
setRecentChooserSelectMultiple :: (MonadIO m, IsRecentChooser o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>select-multiple</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructRecentChooserSelectMultiple :: (IsRecentChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-icons</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentChooser #showIcons
--   </pre>
getRecentChooserShowIcons :: (MonadIO m, IsRecentChooser o) => o -> m Bool

-- | Set the value of the “<tt>show-icons</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentChooser [ #showIcons <a>:=</a> value ]
--   </pre>
setRecentChooserShowIcons :: (MonadIO m, IsRecentChooser o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-icons</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructRecentChooserShowIcons :: (IsRecentChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-not-found</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentChooser #showNotFound
--   </pre>
getRecentChooserShowNotFound :: (MonadIO m, IsRecentChooser o) => o -> m Bool

-- | Set the value of the “<tt>show-not-found</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentChooser [ #showNotFound <a>:=</a> value ]
--   </pre>
setRecentChooserShowNotFound :: (MonadIO m, IsRecentChooser o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-not-found</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructRecentChooserShowNotFound :: (IsRecentChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-private</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentChooser #showPrivate
--   </pre>
getRecentChooserShowPrivate :: (MonadIO m, IsRecentChooser o) => o -> m Bool

-- | Set the value of the “<tt>show-private</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentChooser [ #showPrivate <a>:=</a> value ]
--   </pre>
setRecentChooserShowPrivate :: (MonadIO m, IsRecentChooser o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-private</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructRecentChooserShowPrivate :: (IsRecentChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-tips</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentChooser #showTips
--   </pre>
getRecentChooserShowTips :: (MonadIO m, IsRecentChooser o) => o -> m Bool

-- | Set the value of the “<tt>show-tips</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentChooser [ #showTips <a>:=</a> value ]
--   </pre>
setRecentChooserShowTips :: (MonadIO m, IsRecentChooser o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-tips</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructRecentChooserShowTips :: (IsRecentChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>sort-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentChooser #sortType
--   </pre>
getRecentChooserSortType :: (MonadIO m, IsRecentChooser o) => o -> m RecentSortType

-- | Set the value of the “<tt>sort-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentChooser [ #sortType <a>:=</a> value ]
--   </pre>
setRecentChooserSortType :: (MonadIO m, IsRecentChooser o) => o -> RecentSortType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sort-type</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructRecentChooserSortType :: (IsRecentChooser o, MonadIO m) => RecentSortType -> m (GValueConstruct o)

-- | Adds <i><tt>filter</tt></i> to the list of <a>RecentFilter</a> objects
--   held by <i><tt>chooser</tt></i>.
--   
--   If no previous filter objects were defined, this function will call
--   <a>recentChooserSetFilter</a>.
--   
--   <i>Since: 2.10</i>
recentChooserAddFilter :: (HasCallStack, MonadIO m, IsRecentChooser a, IsRecentFilter b) => a -> b -> m ()

-- | Gets the <a>RecentInfo</a> currently selected by
--   <i><tt>chooser</tt></i>.
--   
--   <i>Since: 2.10</i>
recentChooserGetCurrentItem :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m RecentInfo

-- | Gets the URI currently selected by <i><tt>chooser</tt></i>.
--   
--   <i>Since: 2.10</i>
recentChooserGetCurrentUri :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m Text

-- | Gets the <a>RecentFilter</a> object currently used by
--   <i><tt>chooser</tt></i> to affect the display of the recently used
--   resources.
--   
--   <i>Since: 2.10</i>
recentChooserGetFilter :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m RecentFilter

-- | Gets the list of recently used resources in form of <a>RecentInfo</a>
--   objects.
--   
--   The return value of this function is affected by the “sort-type” and
--   “limit” properties of <i><tt>chooser</tt></i>.
--   
--   <i>Since: 2.10</i>
recentChooserGetItems :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m [RecentInfo]

-- | Gets the number of items returned by <a>recentChooserGetItems</a> and
--   <a>recentChooserGetUris</a>.
--   
--   <i>Since: 2.10</i>
recentChooserGetLimit :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m Int32

-- | Gets whether only local resources should be shown in the recently used
--   resources selector. See <a>recentChooserSetLocalOnly</a>
--   
--   <i>Since: 2.10</i>
recentChooserGetLocalOnly :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m Bool

-- | Gets whether <i><tt>chooser</tt></i> can select multiple items.
--   
--   <i>Since: 2.10</i>
recentChooserGetSelectMultiple :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m Bool

-- | Retrieves whether <i><tt>chooser</tt></i> should show an icon near the
--   resource.
--   
--   <i>Since: 2.10</i>
recentChooserGetShowIcons :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m Bool

-- | Retrieves whether <i><tt>chooser</tt></i> should show the recently
--   used resources that were not found.
--   
--   <i>Since: 2.10</i>
recentChooserGetShowNotFound :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m Bool

-- | Returns whether <i><tt>chooser</tt></i> should display recently used
--   resources registered as private.
--   
--   <i>Since: 2.10</i>
recentChooserGetShowPrivate :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m Bool

-- | Gets whether <i><tt>chooser</tt></i> should display tooltips
--   containing the full path of a recently user resource.
--   
--   <i>Since: 2.10</i>
recentChooserGetShowTips :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m Bool

-- | Gets the value set by <a>recentChooserSetSortType</a>.
--   
--   <i>Since: 2.10</i>
recentChooserGetSortType :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m RecentSortType

-- | Gets the URI of the recently used resources.
--   
--   The return value of this function is affected by the “sort-type” and
--   “limit” properties of <i><tt>chooser</tt></i>.
--   
--   Since the returned array is <a>Nothing</a> terminated,
--   <i><tt>length</tt></i> may be <a>Nothing</a>.
--   
--   <i>Since: 2.10</i>
recentChooserGetUris :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m ([Text], CSize)

-- | Gets the <a>RecentFilter</a> objects held by <i><tt>chooser</tt></i>.
--   
--   <i>Since: 2.10</i>
recentChooserListFilters :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m [RecentFilter]

-- | Removes <i><tt>filter</tt></i> from the list of <a>RecentFilter</a>
--   objects held by <i><tt>chooser</tt></i>.
--   
--   <i>Since: 2.10</i>
recentChooserRemoveFilter :: (HasCallStack, MonadIO m, IsRecentChooser a, IsRecentFilter b) => a -> b -> m ()

-- | Selects all the items inside <i><tt>chooser</tt></i>, if the
--   <i><tt>chooser</tt></i> supports multiple selection.
--   
--   <i>Since: 2.10</i>
recentChooserSelectAll :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m ()

-- | Selects <i><tt>uri</tt></i> inside <i><tt>chooser</tt></i>.
--   
--   <i>Since: 2.10</i>
recentChooserSelectUri :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Text -> m ()

-- | Sets <i><tt>uri</tt></i> as the current URI for
--   <i><tt>chooser</tt></i>.
--   
--   <i>Since: 2.10</i>
recentChooserSetCurrentUri :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Text -> m ()

-- | Sets <i><tt>filter</tt></i> as the current <a>RecentFilter</a> object
--   used by <i><tt>chooser</tt></i> to affect the displayed recently used
--   resources.
--   
--   <i>Since: 2.10</i>
recentChooserSetFilter :: (HasCallStack, MonadIO m, IsRecentChooser a, IsRecentFilter b) => a -> Maybe b -> m ()

-- | Sets the number of items that should be returned by
--   <a>recentChooserGetItems</a> and <a>recentChooserGetUris</a>.
--   
--   <i>Since: 2.10</i>
recentChooserSetLimit :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Int32 -> m ()

-- | Sets whether only local resources, that is resources using the file://
--   URI scheme, should be shown in the recently used resources selector.
--   If <i><tt>localOnly</tt></i> is <a>True</a> (the default) then the
--   shown resources are guaranteed to be accessible through the operating
--   system native file system.
--   
--   <i>Since: 2.10</i>
recentChooserSetLocalOnly :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Bool -> m ()

-- | Sets whether <i><tt>chooser</tt></i> can select multiple items.
--   
--   <i>Since: 2.10</i>
recentChooserSetSelectMultiple :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Bool -> m ()

-- | Sets whether <i><tt>chooser</tt></i> should show an icon near the
--   resource when displaying it.
--   
--   <i>Since: 2.10</i>
recentChooserSetShowIcons :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Bool -> m ()

-- | Sets whether <i><tt>chooser</tt></i> should display the recently used
--   resources that it didn’t find. This only applies to local resources.
--   
--   <i>Since: 2.10</i>
recentChooserSetShowNotFound :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Bool -> m ()

-- | Whether to show recently used resources marked registered as private.
--   
--   <i>Since: 2.10</i>
recentChooserSetShowPrivate :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Bool -> m ()

-- | Sets whether to show a tooltips containing the full path of each
--   recently used resource in a <a>RecentChooser</a> widget.
--   
--   <i>Since: 2.10</i>
recentChooserSetShowTips :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Bool -> m ()

-- | Changes the sorting order of the recently used resources list
--   displayed by <i><tt>chooser</tt></i>.
--   
--   <i>Since: 2.10</i>
recentChooserSetSortType :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> RecentSortType -> m ()

-- | Unselects all the items inside <i><tt>chooser</tt></i>.
--   
--   <i>Since: 2.10</i>
recentChooserUnselectAll :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> m ()

-- | Unselects <i><tt>uri</tt></i> inside <i><tt>chooser</tt></i>.
--   
--   <i>Since: 2.10</i>
recentChooserUnselectUri :: (HasCallStack, MonadIO m, IsRecentChooser a) => a -> Text -> m ()

-- | Connect a signal handler for the <a>itemActivated</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> recentChooser #itemActivated callback
--   </pre>
onRecentChooserItemActivated :: (IsRecentChooser a, MonadIO m) => a -> ((?self :: a) => RecentChooserItemActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>itemActivated</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> recentChooser #itemActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterRecentChooserItemActivated :: (IsRecentChooser a, MonadIO m) => a -> ((?self :: a) => RecentChooserItemActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> recentChooser #selectionChanged callback
--   </pre>
onRecentChooserSelectionChanged :: (IsRecentChooser a, MonadIO m) => a -> ((?self :: a) => RecentChooserSelectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> recentChooser #selectionChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterRecentChooserSelectionChanged :: (IsRecentChooser a, MonadIO m) => a -> ((?self :: a) => RecentChooserSelectionChangedCallback) -> m SignalHandlerId

-- | Cast to <a>RecentChooserWidget</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toRecentChooserWidget :: (MonadIO m, IsRecentChooserWidget o) => o -> m RecentChooserWidget

-- | Creates a new <a>RecentChooserWidget</a> object. This is an embeddable
--   widget used to access the recently used resources list.
--   
--   <i>Since: 2.10</i>
recentChooserWidgetNew :: (HasCallStack, MonadIO m) => m RecentChooserWidget

-- | Creates a new <a>RecentChooserWidget</a> with a specified recent
--   manager.
--   
--   This is useful if you have implemented your own recent manager, or if
--   you have a customized instance of a <a>RecentManager</a> object.
--   
--   <i>Since: 2.10</i>
recentChooserWidgetNewForManager :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> m RecentChooserWidget

-- | Cast to <a>RecentChooserDialog</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toRecentChooserDialog :: (MonadIO m, IsRecentChooserDialog o) => o -> m RecentChooserDialog

-- | Cast to <a>RecentAction</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toRecentAction :: (MonadIO m, IsRecentAction o) => o -> m RecentAction

-- | Get the value of the “<tt>show-numbers</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentAction #showNumbers
--   </pre>
getRecentActionShowNumbers :: (MonadIO m, IsRecentAction o) => o -> m Bool

-- | Set the value of the “<tt>show-numbers</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentAction [ #showNumbers <a>:=</a> value ]
--   </pre>
setRecentActionShowNumbers :: (MonadIO m, IsRecentAction o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-numbers</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructRecentActionShowNumbers :: (IsRecentAction o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>RecentAction</a> object. To add the action to a
--   <a>ActionGroup</a> and set the accelerator for the action, call
--   <a>actionGroupAddActionWithAccel</a>.
--   
--   <i>Since: 2.12</i>
recentActionNew :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Maybe Text -> m RecentAction

-- | Creates a new <a>RecentAction</a> object. To add the action to a
--   <a>ActionGroup</a> and set the accelerator for the action, call
--   <a>actionGroupAddActionWithAccel</a>.
--   
--   <i>Since: 2.12</i>
recentActionNewForManager :: (HasCallStack, MonadIO m, IsRecentManager a) => Text -> Maybe Text -> Maybe Text -> Maybe Text -> Maybe a -> m RecentAction

-- | Returns the value set by <a>recentChooserMenuSetShowNumbers</a>.
--   
--   <i>Since: 2.12</i>
recentActionGetShowNumbers :: (HasCallStack, MonadIO m, IsRecentAction a) => a -> m Bool

-- | Sets whether a number should be added to the items shown by the
--   widgets representing <i><tt>action</tt></i>. The numbers are shown to
--   provide a unique character for a mnemonic to be used inside the menu
--   item's label. Only the first ten items get a number to avoid clashes.
--   
--   <i>Since: 2.12</i>
recentActionSetShowNumbers :: (HasCallStack, MonadIO m, IsRecentAction a) => a -> Bool -> m ()

-- | Cast to <a>FileChooser</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFileChooser :: (MonadIO m, IsFileChooser o) => o -> m FileChooser

-- | Get the value of the “<tt>action</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #action
--   </pre>
getFileChooserAction :: (MonadIO m, IsFileChooser o) => o -> m FileChooserAction

-- | Set the value of the “<tt>action</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooser [ #action <a>:=</a> value ]
--   </pre>
setFileChooserAction :: (MonadIO m, IsFileChooser o) => o -> FileChooserAction -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>action</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFileChooserAction :: (IsFileChooser o, MonadIO m) => FileChooserAction -> m (GValueConstruct o)

-- | Get the value of the “<tt>create-folders</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #createFolders
--   </pre>
getFileChooserCreateFolders :: (MonadIO m, IsFileChooser o) => o -> m Bool

-- | Set the value of the “<tt>create-folders</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooser [ #createFolders <a>:=</a> value ]
--   </pre>
setFileChooserCreateFolders :: (MonadIO m, IsFileChooser o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>create-folders</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructFileChooserCreateFolders :: (IsFileChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>do-overwrite-confirmation</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #doOverwriteConfirmation
--   </pre>
getFileChooserDoOverwriteConfirmation :: (MonadIO m, IsFileChooser o) => o -> m Bool

-- | Set the value of the “<tt>do-overwrite-confirmation</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooser [ #doOverwriteConfirmation <a>:=</a> value ]
--   </pre>
setFileChooserDoOverwriteConfirmation :: (MonadIO m, IsFileChooser o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>do-overwrite-confirmation</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructFileChooserDoOverwriteConfirmation :: (IsFileChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>extra-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #extraWidget
--   </pre>
getFileChooserExtraWidget :: (MonadIO m, IsFileChooser o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>extra-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooser [ #extraWidget <a>:=</a> value ]
--   </pre>
setFileChooserExtraWidget :: (MonadIO m, IsFileChooser o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>extra-widget</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFileChooserExtraWidget :: (IsFileChooser o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>filter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #filter
--   </pre>
getFileChooserFilter :: (MonadIO m, IsFileChooser o) => o -> m (Maybe FileFilter)

-- | Set the value of the “<tt>filter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooser [ #filter <a>:=</a> value ]
--   </pre>
setFileChooserFilter :: (MonadIO m, IsFileChooser o, IsFileFilter a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>filter</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFileChooserFilter :: (IsFileChooser o, MonadIO m, IsFileFilter a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>local-only</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #localOnly
--   </pre>
getFileChooserLocalOnly :: (MonadIO m, IsFileChooser o) => o -> m Bool

-- | Set the value of the “<tt>local-only</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooser [ #localOnly <a>:=</a> value ]
--   </pre>
setFileChooserLocalOnly :: (MonadIO m, IsFileChooser o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>local-only</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFileChooserLocalOnly :: (IsFileChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>preview-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #previewWidget
--   </pre>
getFileChooserPreviewWidget :: (MonadIO m, IsFileChooser o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>preview-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooser [ #previewWidget <a>:=</a> value ]
--   </pre>
setFileChooserPreviewWidget :: (MonadIO m, IsFileChooser o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>preview-widget</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructFileChooserPreviewWidget :: (IsFileChooser o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>preview-widget-active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #previewWidgetActive
--   </pre>
getFileChooserPreviewWidgetActive :: (MonadIO m, IsFileChooser o) => o -> m Bool

-- | Set the value of the “<tt>preview-widget-active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooser [ #previewWidgetActive <a>:=</a> value ]
--   </pre>
setFileChooserPreviewWidgetActive :: (MonadIO m, IsFileChooser o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>preview-widget-active</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructFileChooserPreviewWidgetActive :: (IsFileChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>select-multiple</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #selectMultiple
--   </pre>
getFileChooserSelectMultiple :: (MonadIO m, IsFileChooser o) => o -> m Bool

-- | Set the value of the “<tt>select-multiple</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooser [ #selectMultiple <a>:=</a> value ]
--   </pre>
setFileChooserSelectMultiple :: (MonadIO m, IsFileChooser o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>select-multiple</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructFileChooserSelectMultiple :: (IsFileChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-hidden</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #showHidden
--   </pre>
getFileChooserShowHidden :: (MonadIO m, IsFileChooser o) => o -> m Bool

-- | Set the value of the “<tt>show-hidden</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooser [ #showHidden <a>:=</a> value ]
--   </pre>
setFileChooserShowHidden :: (MonadIO m, IsFileChooser o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-hidden</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFileChooserShowHidden :: (IsFileChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-preview-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #usePreviewLabel
--   </pre>
getFileChooserUsePreviewLabel :: (MonadIO m, IsFileChooser o) => o -> m Bool

-- | Set the value of the “<tt>use-preview-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooser [ #usePreviewLabel <a>:=</a> value ]
--   </pre>
setFileChooserUsePreviewLabel :: (MonadIO m, IsFileChooser o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-preview-label</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructFileChooserUsePreviewLabel :: (IsFileChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Adds a 'choice' to the file chooser. This is typically implemented as
--   a combobox or, for boolean choices, as a checkbutton. You can select a
--   value using <a>fileChooserSetChoice</a> before the dialog is shown,
--   and you can obtain the user-selected value in the <a>response</a>
--   signal handler using <a>fileChooserGetChoice</a>.
--   
--   Compare <a>fileChooserSetExtraWidget</a>.
--   
--   <i>Since: 3.22</i>
fileChooserAddChoice :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> Text -> Maybe [Text] -> Maybe [Text] -> m ()

-- | Adds <i><tt>filter</tt></i> to the list of filters that the user can
--   select between. When a filter is selected, only files that are passed
--   by that filter are displayed.
--   
--   Note that the <i><tt>chooser</tt></i> takes ownership of the filter,
--   so you have to ref and sink it if you want to keep a reference.
--   
--   <i>Since: 2.4</i>
fileChooserAddFilter :: (HasCallStack, MonadIO m, IsFileChooser a, IsFileFilter b) => a -> b -> m ()

-- | Adds a folder to be displayed with the shortcut folders in a file
--   chooser. Note that shortcut folders do not get saved, as they are
--   provided by the application. For example, you can use this to add a
--   “/usr/share/mydrawprogram/Clipart” folder to the volume list.
--   
--   <i>Since: 2.4</i>
fileChooserAddShortcutFolder :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> [Char] -> m ()

-- | Adds a folder URI to be displayed with the shortcut folders in a file
--   chooser. Note that shortcut folders do not get saved, as they are
--   provided by the application. For example, you can use this to add a
--   “file:///usr/share/mydrawprogram/Clipart” folder to the volume list.
--   
--   <i>Since: 2.4</i>
fileChooserAddShortcutFolderUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m ()

-- | Gets the type of operation that the file chooser is performing; see
--   <a>fileChooserSetAction</a>.
--   
--   <i>Since: 2.4</i>
fileChooserGetAction :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m FileChooserAction

-- | Gets the currently selected option in the 'choice' with the given ID.
--   
--   <i>Since: 3.22</i>
fileChooserGetChoice :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m Text

-- | Gets whether file choser will offer to create new folders. See
--   <a>fileChooserSetCreateFolders</a>.
--   
--   <i>Since: 2.18</i>
fileChooserGetCreateFolders :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Bool

-- | Gets the current folder of <i><tt>chooser</tt></i> as a local
--   filename. See <a>fileChooserSetCurrentFolder</a>.
--   
--   Note that this is the folder that the file chooser is currently
--   displaying (e.g. "/home/username/Documents"), which is not the same as
--   the currently-selected folder if the chooser is in
--   <a>FileChooserActionSelectFolder</a> mode (e.g.
--   "/home/username/Documents/selected-folder/". To get the
--   currently-selected folder in that mode, use <a>fileChooserGetUri</a>
--   as the usual way to get the selection.
--   
--   <i>Since: 2.4</i>
fileChooserGetCurrentFolder :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe [Char])

-- | Gets the current folder of <i><tt>chooser</tt></i> as <a>File</a>. See
--   <a>fileChooserGetCurrentFolderUri</a>.
--   
--   <i>Since: 2.14</i>
fileChooserGetCurrentFolderFile :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe File)

-- | Gets the current folder of <i><tt>chooser</tt></i> as an URI. See
--   <a>fileChooserSetCurrentFolderUri</a>.
--   
--   Note that this is the folder that the file chooser is currently
--   displaying (e.g. "file:///home/username/Documents"), which is not the
--   same as the currently-selected folder if the chooser is in
--   <a>FileChooserActionSelectFolder</a> mode (e.g.
--   "file:///home/username/Documents/selected-folder/". To get the
--   currently-selected folder in that mode, use <a>fileChooserGetUri</a>
--   as the usual way to get the selection.
--   
--   <i>Since: 2.4</i>
fileChooserGetCurrentFolderUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe Text)

-- | Gets the current name in the file selector, as entered by the user in
--   the text entry for “Name”.
--   
--   This is meant to be used in save dialogs, to get the currently typed
--   filename when the file itself does not exist yet. For example, an
--   application that adds a custom extra widget to the file chooser for
--   “file format” may want to change the extension of the typed filename
--   based on the chosen format, say, from “.jpg” to “.png”.
--   
--   <i>Since: 3.10</i>
fileChooserGetCurrentName :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Text

-- | Queries whether a file chooser is set to confirm for overwriting when
--   the user types a file name that already exists.
--   
--   <i>Since: 2.8</i>
fileChooserGetDoOverwriteConfirmation :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Bool

-- | Gets the current extra widget; see <a>fileChooserSetExtraWidget</a>.
--   
--   <i>Since: 2.4</i>
fileChooserGetExtraWidget :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe Widget)

-- | Gets the <a>File</a> for the currently selected file in the file
--   selector. If multiple files are selected, one of the files will be
--   returned at random.
--   
--   If the file chooser is in folder mode, this function returns the
--   selected folder.
--   
--   <i>Since: 2.14</i>
fileChooserGetFile :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m File

-- | Gets the filename for the currently selected file in the file
--   selector. The filename is returned as an absolute path. If multiple
--   files are selected, one of the filenames will be returned at random.
--   
--   If the file chooser is in folder mode, this function returns the
--   selected folder.
--   
--   <i>Since: 2.4</i>
fileChooserGetFilename :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe [Char])

-- | Lists all the selected files and subfolders in the current folder of
--   <i><tt>chooser</tt></i>. The returned names are full absolute paths.
--   If files in the current folder cannot be represented as local
--   filenames they will be ignored. (See <a>fileChooserGetUris</a>)
--   
--   <i>Since: 2.4</i>
fileChooserGetFilenames :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m [[Char]]

-- | Lists all the selected files and subfolders in the current folder of
--   <i><tt>chooser</tt></i> as <a>File</a>. An internal function, see
--   <a>fileChooserGetUris</a>.
--   
--   <i>Since: 2.14</i>
fileChooserGetFiles :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m [File]

-- | Gets the current filter; see <a>fileChooserSetFilter</a>.
--   
--   <i>Since: 2.4</i>
fileChooserGetFilter :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe FileFilter)

-- | Gets whether only local files can be selected in the file selector.
--   See <a>fileChooserSetLocalOnly</a>
--   
--   <i>Since: 2.4</i>
fileChooserGetLocalOnly :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Bool

-- | Gets the <a>File</a> that should be previewed in a custom preview
--   Internal function, see <a>fileChooserGetPreviewUri</a>.
--   
--   <i>Since: 2.14</i>
fileChooserGetPreviewFile :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe File)

-- | Gets the filename that should be previewed in a custom preview widget.
--   See <a>fileChooserSetPreviewWidget</a>.
--   
--   <i>Since: 2.4</i>
fileChooserGetPreviewFilename :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe [Char])

-- | Gets the URI that should be previewed in a custom preview widget. See
--   <a>fileChooserSetPreviewWidget</a>.
--   
--   <i>Since: 2.4</i>
fileChooserGetPreviewUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe Text)

-- | Gets the current preview widget; see
--   <a>fileChooserSetPreviewWidget</a>.
--   
--   <i>Since: 2.4</i>
fileChooserGetPreviewWidget :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe Widget)

-- | Gets whether the preview widget set by
--   <a>fileChooserSetPreviewWidget</a> should be shown for the current
--   filename. See <a>fileChooserSetPreviewWidgetActive</a>.
--   
--   <i>Since: 2.4</i>
fileChooserGetPreviewWidgetActive :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Bool

-- | Gets whether multiple files can be selected in the file selector. See
--   <a>fileChooserSetSelectMultiple</a>.
--   
--   <i>Since: 2.4</i>
fileChooserGetSelectMultiple :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Bool

-- | Gets whether hidden files and folders are displayed in the file
--   selector. See <a>fileChooserSetShowHidden</a>.
--   
--   <i>Since: 2.6</i>
fileChooserGetShowHidden :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Bool

-- | Gets the URI for the currently selected file in the file selector. If
--   multiple files are selected, one of the filenames will be returned at
--   random.
--   
--   If the file chooser is in folder mode, this function returns the
--   selected folder.
--   
--   <i>Since: 2.4</i>
fileChooserGetUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe Text)

-- | Lists all the selected files and subfolders in the current folder of
--   <i><tt>chooser</tt></i>. The returned names are full absolute URIs.
--   
--   <i>Since: 2.4</i>
fileChooserGetUris :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m [Text]

-- | Gets whether a stock label should be drawn with the name of the
--   previewed file. See <a>fileChooserSetUsePreviewLabel</a>.
fileChooserGetUsePreviewLabel :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Bool

-- | Lists the current set of user-selectable filters; see
--   <a>fileChooserAddFilter</a>, <a>fileChooserRemoveFilter</a>.
--   
--   <i>Since: 2.4</i>
fileChooserListFilters :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m [FileFilter]

-- | Queries the list of shortcut folders in the file chooser, as set by
--   <a>fileChooserAddShortcutFolderUri</a>.
--   
--   <i>Since: 2.4</i>
fileChooserListShortcutFolderUris :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m [Text]

-- | Queries the list of shortcut folders in the file chooser, as set by
--   <a>fileChooserAddShortcutFolder</a>.
--   
--   <i>Since: 2.4</i>
fileChooserListShortcutFolders :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m [[Char]]

-- | Removes a 'choice' that has been added with
--   <a>fileChooserAddChoice</a>.
--   
--   <i>Since: 3.22</i>
fileChooserRemoveChoice :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m ()

-- | Removes <i><tt>filter</tt></i> from the list of filters that the user
--   can select between.
--   
--   <i>Since: 2.4</i>
fileChooserRemoveFilter :: (HasCallStack, MonadIO m, IsFileChooser a, IsFileFilter b) => a -> b -> m ()

-- | Removes a folder from a file chooser’s list of shortcut folders.
--   
--   <i>Since: 2.4</i>
fileChooserRemoveShortcutFolder :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> [Char] -> m ()

-- | Removes a folder URI from a file chooser’s list of shortcut folders.
--   
--   <i>Since: 2.4</i>
fileChooserRemoveShortcutFolderUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m ()

-- | Selects all the files in the current folder of a file chooser.
--   
--   <i>Since: 2.4</i>
fileChooserSelectAll :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m ()

-- | Selects the file referred to by <i><tt>file</tt></i>. An internal
--   function. See <tt><i>_gtk_file_chooser_select_uri()</i></tt>.
--   
--   <i>Since: 2.14</i>
fileChooserSelectFile :: (HasCallStack, MonadIO m, IsFileChooser a, IsFile b) => a -> b -> m ()

-- | Selects a filename. If the file name isn’t in the current folder of
--   <i><tt>chooser</tt></i>, then the current folder of
--   <i><tt>chooser</tt></i> will be changed to the folder containing
--   <i><tt>filename</tt></i>.
--   
--   <i>Since: 2.4</i>
fileChooserSelectFilename :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> [Char] -> m Bool

-- | Selects the file to by <i><tt>uri</tt></i>. If the URI doesn’t refer
--   to a file in the current folder of <i><tt>chooser</tt></i>, then the
--   current folder of <i><tt>chooser</tt></i> will be changed to the
--   folder containing <i><tt>filename</tt></i>.
--   
--   <i>Since: 2.4</i>
fileChooserSelectUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m Bool

-- | Sets the type of operation that the chooser is performing; the user
--   interface is adapted to suit the selected action. For example, an
--   option to create a new folder might be shown if the action is
--   <a>FileChooserActionSave</a> but not if the action is
--   <a>FileChooserActionOpen</a>.
--   
--   <i>Since: 2.4</i>
fileChooserSetAction :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> FileChooserAction -> m ()

-- | Selects an option in a 'choice' that has been added with
--   <a>fileChooserAddChoice</a>. For a boolean choice, the possible
--   options are "true" and "false".
--   
--   <i>Since: 3.22</i>
fileChooserSetChoice :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> Text -> m ()

-- | Sets whether file choser will offer to create new folders. This is
--   only relevant if the action is not set to be
--   <a>FileChooserActionOpen</a>.
--   
--   <i>Since: 2.18</i>
fileChooserSetCreateFolders :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Bool -> m ()

-- | Sets the current folder for <i><tt>chooser</tt></i> from a local
--   filename. The user will be shown the full contents of the current
--   folder, plus user interface elements for navigating to other folders.
--   
--   In general, you should not use this function. See the [section on
--   setting up a file chooser dialog][gtkfilechooserdialog-setting-up] for
--   the rationale behind this.
--   
--   <i>Since: 2.4</i>
fileChooserSetCurrentFolder :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> [Char] -> m Bool

-- | Sets the current folder for <i><tt>chooser</tt></i> from a
--   <a>File</a>. Internal function, see
--   <a>fileChooserSetCurrentFolderUri</a>.
--   
--   <i>Since: 2.14</i>
fileChooserSetCurrentFolderFile :: (HasCallStack, MonadIO m, IsFileChooser a, IsFile b) => a -> b -> m ()

-- | Sets the current folder for <i><tt>chooser</tt></i> from an URI. The
--   user will be shown the full contents of the current folder, plus user
--   interface elements for navigating to other folders.
--   
--   In general, you should not use this function. See the [section on
--   setting up a file chooser dialog][gtkfilechooserdialog-setting-up] for
--   the rationale behind this.
--   
--   <i>Since: 2.4</i>
fileChooserSetCurrentFolderUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m Bool

-- | Sets the current name in the file selector, as if entered by the user.
--   Note that the name passed in here is a UTF-8 string rather than a
--   filename. This function is meant for such uses as a suggested name in
--   a “Save As...” dialog. You can pass “Untitled.doc” or a similarly
--   suitable suggestion for the <i><tt>name</tt></i>.
--   
--   If you want to preselect a particular existing file, you should use
--   <a>fileChooserSetFilename</a> or <a>fileChooserSetUri</a> instead.
--   Please see the documentation for those functions for an example of
--   using <a>fileChooserSetCurrentName</a> as well.
--   
--   <i>Since: 2.4</i>
fileChooserSetCurrentName :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m ()

-- | Sets whether a file chooser in <a>FileChooserActionSave</a> mode will
--   present a confirmation dialog if the user types a file name that
--   already exists. This is <a>False</a> by default.
--   
--   If set to <a>True</a>, the <i><tt>chooser</tt></i> will emit the
--   <a>FileChooser::confirmOverwrite</a> signal when appropriate.
--   
--   If all you need is the stock confirmation dialog, set this property to
--   <a>True</a>. You can override the way confirmation is done by actually
--   handling the <a>FileChooser::confirmOverwrite</a> signal; please refer
--   to its documentation for the details.
--   
--   <i>Since: 2.8</i>
fileChooserSetDoOverwriteConfirmation :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Bool -> m ()

-- | Sets an application-supplied widget to provide extra options to the
--   user.
--   
--   <i>Since: 2.4</i>
fileChooserSetExtraWidget :: (HasCallStack, MonadIO m, IsFileChooser a, IsWidget b) => a -> b -> m ()

-- | Sets <i><tt>file</tt></i> as the current filename for the file
--   chooser, by changing to the file’s parent folder and actually
--   selecting the file in list. If the <i><tt>chooser</tt></i> is in
--   <a>FileChooserActionSave</a> mode, the file’s base name will also
--   appear in the dialog’s file name entry.
--   
--   If the file name isn’t in the current folder of
--   <i><tt>chooser</tt></i>, then the current folder of
--   <i><tt>chooser</tt></i> will be changed to the folder containing
--   <i><tt>filename</tt></i>. This is equivalent to a sequence of
--   <a>fileChooserUnselectAll</a> followed by
--   <a>fileChooserSelectFilename</a>.
--   
--   Note that the file must exist, or nothing will be done except for the
--   directory change.
--   
--   If you are implementing a save dialog, you should use this function if
--   you already have a file name to which the user may save; for example,
--   when the user opens an existing file and then does Save As... If you
--   don’t have a file name already — for example, if the user just created
--   a new file and is saving it for the first time, do not call this
--   function. Instead, use something similar to this:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   if (document_is_new)
--     {
--       // the user just created a new document
--       gtk_file_chooser_set_current_folder_file (chooser, default_file_for_saving);
--       gtk_file_chooser_set_current_name (chooser, "Untitled document");
--     }
--   else
--     {
--       // the user edited an existing document
--       gtk_file_chooser_set_file (chooser, existing_file);
--     }
--   </pre>
--   
--   <i>Since: 2.14</i>
fileChooserSetFile :: (HasCallStack, MonadIO m, IsFileChooser a, IsFile b) => a -> b -> m ()

-- | Sets <i><tt>filename</tt></i> as the current filename for the file
--   chooser, by changing to the file’s parent folder and actually
--   selecting the file in list; all other files will be unselected. If the
--   <i><tt>chooser</tt></i> is in <a>FileChooserActionSave</a> mode, the
--   file’s base name will also appear in the dialog’s file name entry.
--   
--   Note that the file must exist, or nothing will be done except for the
--   directory change.
--   
--   You should use this function only when implementing a save dialog for
--   which you already have a file name to which the user may save. For
--   example, when the user opens an existing file and then does Save As...
--   to save a copy or a modified version. If you don’t have a file name
--   already — for example, if the user just created a new file and is
--   saving it for the first time, do not call this function. Instead, use
--   something similar to this:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   if (document_is_new)
--     {
--       // the user just created a new document
--       gtk_file_chooser_set_current_name (chooser, "Untitled document");
--     }
--   else
--     {
--       // the user edited an existing document
--       gtk_file_chooser_set_filename (chooser, existing_filename);
--     }
--   </pre>
--   
--   In the first case, the file chooser will present the user with useful
--   suggestions as to where to save his new file. In the second case, the
--   file’s existing location is already known, so the file chooser will
--   use it.
--   
--   <i>Since: 2.4</i>
fileChooserSetFilename :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> [Char] -> m Bool

-- | Sets the current filter; only the files that pass the filter will be
--   displayed. If the user-selectable list of filters is non-empty, then
--   the filter should be one of the filters in that list. Setting the
--   current filter when the list of filters is empty is useful if you want
--   to restrict the displayed set of files without letting the user change
--   it.
--   
--   <i>Since: 2.4</i>
fileChooserSetFilter :: (HasCallStack, MonadIO m, IsFileChooser a, IsFileFilter b) => a -> b -> m ()

-- | Sets whether only local files can be selected in the file selector. If
--   <i><tt>localOnly</tt></i> is <a>True</a> (the default), then the
--   selected file or files are guaranteed to be accessible through the
--   operating systems native file system and therefore the application
--   only needs to worry about the filename functions in
--   <a>FileChooser</a>, like <a>fileChooserGetFilename</a>, rather than
--   the URI functions like <a>fileChooserGetUri</a>,
--   
--   On some systems non-native files may still be available using the
--   native filesystem via a userspace filesystem (FUSE).
--   
--   <i>Since: 2.4</i>
fileChooserSetLocalOnly :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Bool -> m ()

-- | Sets an application-supplied widget to use to display a custom preview
--   of the currently selected file. To implement a preview, after setting
--   the preview widget, you connect to the
--   <a>FileChooser::updatePreview</a> signal, and call
--   <a>fileChooserGetPreviewFilename</a> or
--   <a>fileChooserGetPreviewUri</a> on each change. If you can display a
--   preview of the new file, update your widget and set the preview active
--   using <a>fileChooserSetPreviewWidgetActive</a>. Otherwise, set the
--   preview inactive.
--   
--   When there is no application-supplied preview widget, or the
--   application-supplied preview widget is not active, the file chooser
--   will display no preview at all.
--   
--   <i>Since: 2.4</i>
fileChooserSetPreviewWidget :: (HasCallStack, MonadIO m, IsFileChooser a, IsWidget b) => a -> b -> m ()

-- | Sets whether the preview widget set by
--   <a>fileChooserSetPreviewWidget</a> should be shown for the current
--   filename. When <i><tt>active</tt></i> is set to false, the file
--   chooser may display an internally generated preview of the current
--   file or it may display no preview at all. See
--   <a>fileChooserSetPreviewWidget</a> for more details.
--   
--   <i>Since: 2.4</i>
fileChooserSetPreviewWidgetActive :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Bool -> m ()

-- | Sets whether multiple files can be selected in the file selector. This
--   is only relevant if the action is set to be
--   <a>FileChooserActionOpen</a> or <a>FileChooserActionSelectFolder</a>.
--   
--   <i>Since: 2.4</i>
fileChooserSetSelectMultiple :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Bool -> m ()

-- | Sets whether hidden files and folders are displayed in the file
--   selector.
--   
--   <i>Since: 2.6</i>
fileChooserSetShowHidden :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Bool -> m ()

-- | Sets the file referred to by <i><tt>uri</tt></i> as the current file
--   for the file chooser, by changing to the URI’s parent folder and
--   actually selecting the URI in the list. If the <i><tt>chooser</tt></i>
--   is <a>FileChooserActionSave</a> mode, the URI’s base name will also
--   appear in the dialog’s file name entry.
--   
--   Note that the URI must exist, or nothing will be done except for the
--   directory change.
--   
--   You should use this function only when implementing a save dialog for
--   which you already have a file name to which the user may save. For
--   example, when the user opens an existing file and then does Save As...
--   to save a copy or a modified version. If you don’t have a file name
--   already — for example, if the user just created a new file and is
--   saving it for the first time, do not call this function. Instead, use
--   something similar to this:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   if (document_is_new)
--     {
--       // the user just created a new document
--       gtk_file_chooser_set_current_name (chooser, "Untitled document");
--     }
--   else
--     {
--       // the user edited an existing document
--       gtk_file_chooser_set_uri (chooser, existing_uri);
--     }
--   </pre>
--   
--   In the first case, the file chooser will present the user with useful
--   suggestions as to where to save his new file. In the second case, the
--   file’s existing location is already known, so the file chooser will
--   use it.
--   
--   <i>Since: 2.4</i>
fileChooserSetUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m Bool

-- | Sets whether the file chooser should display a stock label with the
--   name of the file that is being previewed; the default is <a>True</a>.
--   Applications that want to draw the whole preview area themselves
--   should set this to <a>False</a> and display the name themselves in
--   their preview widget.
--   
--   See also: <a>fileChooserSetPreviewWidget</a>
--   
--   <i>Since: 2.4</i>
fileChooserSetUsePreviewLabel :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Bool -> m ()

-- | Unselects all the files in the current folder of a file chooser.
--   
--   <i>Since: 2.4</i>
fileChooserUnselectAll :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m ()

-- | Unselects the file referred to by <i><tt>file</tt></i>. If the file is
--   not in the current directory, does not exist, or is otherwise not
--   currently selected, does nothing.
--   
--   <i>Since: 2.14</i>
fileChooserUnselectFile :: (HasCallStack, MonadIO m, IsFileChooser a, IsFile b) => a -> b -> m ()

-- | Unselects a currently selected filename. If the filename is not in the
--   current directory, does not exist, or is otherwise not currently
--   selected, does nothing.
--   
--   <i>Since: 2.4</i>
fileChooserUnselectFilename :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> [Char] -> m ()

-- | Unselects the file referred to by <i><tt>uri</tt></i>. If the file is
--   not in the current directory, does not exist, or is otherwise not
--   currently selected, does nothing.
--   
--   <i>Since: 2.4</i>
fileChooserUnselectUri :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m ()

-- | Connect a signal handler for the <a>confirmOverwrite</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooser #confirmOverwrite callback
--   </pre>
onFileChooserConfirmOverwrite :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserConfirmOverwriteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>confirmOverwrite</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooser #confirmOverwrite callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserConfirmOverwrite :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserConfirmOverwriteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>currentFolderChanged</a> signal,
--   to be run before the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooser #currentFolderChanged callback
--   </pre>
onFileChooserCurrentFolderChanged :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserCurrentFolderChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>currentFolderChanged</a> signal,
--   to be run after the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooser #currentFolderChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserCurrentFolderChanged :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserCurrentFolderChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>fileActivated</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooser #fileActivated callback
--   </pre>
onFileChooserFileActivated :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserFileActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>fileActivated</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooser #fileActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserFileActivated :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserFileActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooser #selectionChanged callback
--   </pre>
onFileChooserSelectionChanged :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserSelectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooser #selectionChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserSelectionChanged :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserSelectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>updatePreview</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooser #updatePreview callback
--   </pre>
onFileChooserUpdatePreview :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserUpdatePreviewCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>updatePreview</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooser #updatePreview callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserUpdatePreview :: (IsFileChooser a, MonadIO m) => a -> ((?self :: a) => FileChooserUpdatePreviewCallback) -> m SignalHandlerId

-- | Cast to <a>FileChooserWidget</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFileChooserWidget :: (MonadIO m, IsFileChooserWidget o) => o -> m FileChooserWidget

-- | Connect a signal handler for the <a>desktopFolder</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #desktopFolder callback
--   </pre>
onFileChooserWidgetDesktopFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetDesktopFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>desktopFolder</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #desktopFolder callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetDesktopFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetDesktopFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>downFolder</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #downFolder callback
--   </pre>
onFileChooserWidgetDownFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetDownFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>downFolder</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #downFolder callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetDownFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetDownFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>homeFolder</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #homeFolder callback
--   </pre>
onFileChooserWidgetHomeFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetHomeFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>homeFolder</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #homeFolder callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetHomeFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetHomeFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>locationPopup</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #locationPopup callback
--   </pre>
onFileChooserWidgetLocationPopup :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationPopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>locationPopup</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #locationPopup callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetLocationPopup :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationPopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>locationPopupOnPaste</a> signal,
--   to be run before the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #locationPopupOnPaste callback
--   </pre>
onFileChooserWidgetLocationPopupOnPaste :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationPopupOnPasteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>locationPopupOnPaste</a> signal,
--   to be run after the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #locationPopupOnPaste callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetLocationPopupOnPaste :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationPopupOnPasteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>locationTogglePopup</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #locationTogglePopup callback
--   </pre>
onFileChooserWidgetLocationTogglePopup :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationTogglePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>locationTogglePopup</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #locationTogglePopup callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetLocationTogglePopup :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationTogglePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>placesShortcut</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #placesShortcut callback
--   </pre>
onFileChooserWidgetPlacesShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetPlacesShortcutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>placesShortcut</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #placesShortcut callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetPlacesShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetPlacesShortcutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>quickBookmark</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #quickBookmark callback
--   </pre>
onFileChooserWidgetQuickBookmark :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetQuickBookmarkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>quickBookmark</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #quickBookmark callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetQuickBookmark :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetQuickBookmarkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>recentShortcut</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #recentShortcut callback
--   </pre>
onFileChooserWidgetRecentShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetRecentShortcutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>recentShortcut</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #recentShortcut callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetRecentShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetRecentShortcutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>searchShortcut</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #searchShortcut callback
--   </pre>
onFileChooserWidgetSearchShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetSearchShortcutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>searchShortcut</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #searchShortcut callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetSearchShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetSearchShortcutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showHidden</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #showHidden callback
--   </pre>
onFileChooserWidgetShowHidden :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetShowHiddenCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showHidden</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #showHidden callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetShowHidden :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetShowHiddenCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>upFolder</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #upFolder callback
--   </pre>
onFileChooserWidgetUpFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetUpFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>upFolder</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #upFolder callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetUpFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetUpFolderCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>search-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooserWidget #searchMode
--   </pre>
getFileChooserWidgetSearchMode :: (MonadIO m, IsFileChooserWidget o) => o -> m Bool

-- | Set the value of the “<tt>search-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooserWidget [ #searchMode <a>:=</a> value ]
--   </pre>
setFileChooserWidgetSearchMode :: (MonadIO m, IsFileChooserWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>search-mode</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFileChooserWidgetSearchMode :: (IsFileChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>subtitle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooserWidget #subtitle
--   </pre>
getFileChooserWidgetSubtitle :: (MonadIO m, IsFileChooserWidget o) => o -> m (Maybe Text)

-- | Creates a new <a>FileChooserWidget</a>. This is a file chooser widget
--   that can be embedded in custom windows, and it is the same widget that
--   is used by <a>FileChooserDialog</a>.
--   
--   <i>Since: 2.4</i>
fileChooserWidgetNew :: (HasCallStack, MonadIO m) => FileChooserAction -> m FileChooserWidget

-- | Cast to <a>FileChooserNative</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFileChooserNative :: (MonadIO m, IsFileChooserNative o) => o -> m FileChooserNative

-- | Get the value of the “<tt>accept-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooserNative #acceptLabel
--   </pre>
getFileChooserNativeAcceptLabel :: (MonadIO m, IsFileChooserNative o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>accept-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooserNative [ #acceptLabel <a>:=</a> value ]
--   </pre>
setFileChooserNativeAcceptLabel :: (MonadIO m, IsFileChooserNative o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accept-label</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFileChooserNativeAcceptLabel :: (IsFileChooserNative o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>accept-label</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #acceptLabel
--   </pre>
clearFileChooserNativeAcceptLabel :: (MonadIO m, IsFileChooserNative o) => o -> m ()

-- | Get the value of the “<tt>cancel-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooserNative #cancelLabel
--   </pre>
getFileChooserNativeCancelLabel :: (MonadIO m, IsFileChooserNative o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>cancel-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooserNative [ #cancelLabel <a>:=</a> value ]
--   </pre>
setFileChooserNativeCancelLabel :: (MonadIO m, IsFileChooserNative o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cancel-label</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFileChooserNativeCancelLabel :: (IsFileChooserNative o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>cancel-label</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #cancelLabel
--   </pre>
clearFileChooserNativeCancelLabel :: (MonadIO m, IsFileChooserNative o) => o -> m ()

-- | Creates a new <a>FileChooserNative</a>.
--   
--   <i>Since: 3.20</i>
fileChooserNativeNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe Text -> Maybe a -> FileChooserAction -> Maybe Text -> Maybe Text -> m FileChooserNative

-- | Retrieves the custom label text for the accept button.
--   
--   <i>Since: 3.20</i>
fileChooserNativeGetAcceptLabel :: (HasCallStack, MonadIO m, IsFileChooserNative a) => a -> m (Maybe Text)

-- | Retrieves the custom label text for the cancel button.
--   
--   <i>Since: 3.20</i>
fileChooserNativeGetCancelLabel :: (HasCallStack, MonadIO m, IsFileChooserNative a) => a -> m (Maybe Text)

-- | Sets the custom label text for the accept button.
--   
--   If characters in <i><tt>label</tt></i> are preceded by an underscore,
--   they are underlined. If you need a literal underscore character in a
--   label, use “__” (two underscores). The first underlined character
--   represents a keyboard accelerator called a mnemonic. Pressing Alt and
--   that key activates the button.
--   
--   <i>Since: 3.20</i>
fileChooserNativeSetAcceptLabel :: (HasCallStack, MonadIO m, IsFileChooserNative a) => a -> Maybe Text -> m ()

-- | Sets the custom label text for the cancel button.
--   
--   If characters in <i><tt>label</tt></i> are preceded by an underscore,
--   they are underlined. If you need a literal underscore character in a
--   label, use “__” (two underscores). The first underlined character
--   represents a keyboard accelerator called a mnemonic. Pressing Alt and
--   that key activates the button.
--   
--   <i>Since: 3.20</i>
fileChooserNativeSetCancelLabel :: (HasCallStack, MonadIO m, IsFileChooserNative a) => a -> Maybe Text -> m ()

-- | Cast to <a>FileChooserDialog</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFileChooserDialog :: (MonadIO m, IsFileChooserDialog o) => o -> m FileChooserDialog

-- | Cast to <a>FileChooserButton</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFileChooserButton :: (MonadIO m, IsFileChooserButton o) => o -> m FileChooserButton

-- | Connect a signal handler for the <a>fileSet</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserButton #fileSet callback
--   </pre>
onFileChooserButtonFileSet :: (IsFileChooserButton a, MonadIO m) => a -> ((?self :: a) => FileChooserButtonFileSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>fileSet</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserButton #fileSet callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserButtonFileSet :: (IsFileChooserButton a, MonadIO m) => a -> ((?self :: a) => FileChooserButtonFileSetCallback) -> m SignalHandlerId

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>dialog</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFileChooserButtonDialog :: (IsFileChooserButton o, MonadIO m, IsFileChooser a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooserButton #title
--   </pre>
getFileChooserButtonTitle :: (MonadIO m, IsFileChooserButton o) => o -> m Text

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooserButton [ #title <a>:=</a> value ]
--   </pre>
setFileChooserButtonTitle :: (MonadIO m, IsFileChooserButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFileChooserButtonTitle :: (IsFileChooserButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooserButton #widthChars
--   </pre>
getFileChooserButtonWidthChars :: (MonadIO m, IsFileChooserButton o) => o -> m Int32

-- | Set the value of the “<tt>width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooserButton [ #widthChars <a>:=</a> value ]
--   </pre>
setFileChooserButtonWidthChars :: (MonadIO m, IsFileChooserButton o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>width-chars</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFileChooserButtonWidthChars :: (IsFileChooserButton o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new file-selecting button widget.
--   
--   <i>Since: 2.6</i>
fileChooserButtonNew :: (HasCallStack, MonadIO m) => Text -> FileChooserAction -> m FileChooserButton

-- | Creates a <a>FileChooserButton</a> widget which uses
--   <i><tt>dialog</tt></i> as its file-picking window.
--   
--   Note that <i><tt>dialog</tt></i> must be a <a>Dialog</a> (or subclass)
--   which implements the <a>FileChooser</a> interface and must not have
--   <a>DialogFlagsDestroyWithParent</a> set.
--   
--   Also note that the dialog needs to have its confirmative button added
--   with response <a>ResponseTypeAccept</a> or <a>ResponseTypeOk</a> in
--   order for the button to take over the file selected in the dialog.
--   
--   <i>Since: 2.6</i>
fileChooserButtonNewWithDialog :: (HasCallStack, MonadIO m, IsDialog a) => a -> m FileChooserButton

-- | Returns whether the button grabs focus when it is clicked with the
--   mouse. See <a>fileChooserButtonSetFocusOnClick</a>.
--   
--   <i>Since: 2.10</i>
fileChooserButtonGetFocusOnClick :: (HasCallStack, MonadIO m, IsFileChooserButton a) => a -> m Bool

-- | Retrieves the title of the browse dialog used by
--   <i><tt>button</tt></i>. The returned value should not be modified or
--   freed.
--   
--   <i>Since: 2.6</i>
fileChooserButtonGetTitle :: (HasCallStack, MonadIO m, IsFileChooserButton a) => a -> m Text

-- | Retrieves the width in characters of the <i><tt>button</tt></i>
--   widget’s entry and/or label.
--   
--   <i>Since: 2.6</i>
fileChooserButtonGetWidthChars :: (HasCallStack, MonadIO m, IsFileChooserButton a) => a -> m Int32

-- | Sets whether the button will grab focus when it is clicked with the
--   mouse. Making mouse clicks not grab focus is useful in places like
--   toolbars where you don’t want the keyboard focus removed from the main
--   area of the application.
--   
--   <i>Since: 2.10</i>
fileChooserButtonSetFocusOnClick :: (HasCallStack, MonadIO m, IsFileChooserButton a) => a -> Bool -> m ()

-- | Modifies the <i><tt>title</tt></i> of the browse dialog used by
--   <i><tt>button</tt></i>.
--   
--   <i>Since: 2.6</i>
fileChooserButtonSetTitle :: (HasCallStack, MonadIO m, IsFileChooserButton a) => a -> Text -> m ()

-- | Sets the width (in characters) that <i><tt>button</tt></i> will use to
--   <i><tt>nChars</tt></i>.
--   
--   <i>Since: 2.6</i>
fileChooserButtonSetWidthChars :: (HasCallStack, MonadIO m, IsFileChooserButton a) => a -> Int32 -> m ()

-- | Cast to <a>RendererCellAccessible</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toRendererCellAccessible :: (MonadIO m, IsRendererCellAccessible o) => o -> m RendererCellAccessible

-- | Get the value of the “<tt>renderer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> rendererCellAccessible #renderer
--   </pre>
getRendererCellAccessibleRenderer :: (MonadIO m, IsRendererCellAccessible o) => o -> m (Maybe CellRenderer)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>renderer</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructRendererCellAccessibleRenderer :: (IsRendererCellAccessible o, MonadIO m, IsCellRenderer a) => a -> m (GValueConstruct o)

-- | <i>No description available in the introspection data.</i>
rendererCellAccessibleNew :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m RendererCellAccessible

-- | Cast to <a>TextCellAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toTextCellAccessible :: (MonadIO m, IsTextCellAccessible o) => o -> m TextCellAccessible

-- | Cast to <a>ImageCellAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toImageCellAccessible :: (MonadIO m, IsImageCellAccessible o) => o -> m ImageCellAccessible

-- | Cast to <a>CellRendererToggle</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toCellRendererToggle :: (MonadIO m, IsCellRendererToggle o) => o -> m CellRendererToggle

-- | Connect a signal handler for the <a>toggled</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellRendererToggle #toggled callback
--   </pre>
onCellRendererToggleToggled :: (IsCellRendererToggle a, MonadIO m) => a -> ((?self :: a) => CellRendererToggleToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggled</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellRendererToggle #toggled callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellRendererToggleToggled :: (IsCellRendererToggle a, MonadIO m) => a -> ((?self :: a) => CellRendererToggleToggledCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>activatable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererToggle #activatable
--   </pre>
getCellRendererToggleActivatable :: (MonadIO m, IsCellRendererToggle o) => o -> m Bool

-- | Set the value of the “<tt>activatable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererToggle [ #activatable <a>:=</a> value ]
--   </pre>
setCellRendererToggleActivatable :: (MonadIO m, IsCellRendererToggle o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activatable</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererToggleActivatable :: (IsCellRendererToggle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererToggle #active
--   </pre>
getCellRendererToggleActive :: (MonadIO m, IsCellRendererToggle o) => o -> m Bool

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererToggle [ #active <a>:=</a> value ]
--   </pre>
setCellRendererToggleActive :: (MonadIO m, IsCellRendererToggle o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererToggleActive :: (IsCellRendererToggle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>inconsistent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererToggle #inconsistent
--   </pre>
getCellRendererToggleInconsistent :: (MonadIO m, IsCellRendererToggle o) => o -> m Bool

-- | Set the value of the “<tt>inconsistent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererToggle [ #inconsistent <a>:=</a> value ]
--   </pre>
setCellRendererToggleInconsistent :: (MonadIO m, IsCellRendererToggle o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inconsistent</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererToggleInconsistent :: (IsCellRendererToggle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>indicator-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererToggle #indicatorSize
--   </pre>
getCellRendererToggleIndicatorSize :: (MonadIO m, IsCellRendererToggle o) => o -> m Int32

-- | Set the value of the “<tt>indicator-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererToggle [ #indicatorSize <a>:=</a> value ]
--   </pre>
setCellRendererToggleIndicatorSize :: (MonadIO m, IsCellRendererToggle o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>indicator-size</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererToggleIndicatorSize :: (IsCellRendererToggle o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>radio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererToggle #radio
--   </pre>
getCellRendererToggleRadio :: (MonadIO m, IsCellRendererToggle o) => o -> m Bool

-- | Set the value of the “<tt>radio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererToggle [ #radio <a>:=</a> value ]
--   </pre>
setCellRendererToggleRadio :: (MonadIO m, IsCellRendererToggle o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>radio</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererToggleRadio :: (IsCellRendererToggle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>CellRendererToggle</a>. Adjust rendering parameters
--   using object properties. Object properties can be set globally (with
--   <tt><i>g_object_set()</i></tt>). Also, with <a>TreeViewColumn</a>, you
--   can bind a property to a value in a <a>TreeModel</a>. For example, you
--   can bind the “active” property on the cell renderer to a boolean value
--   in the model, thus causing the check button to reflect the state of
--   the model.
cellRendererToggleNew :: (HasCallStack, MonadIO m) => m CellRendererToggle

-- | Returns whether the cell renderer is activatable. See
--   <a>cellRendererToggleSetActivatable</a>.
--   
--   <i>Since: 2.18</i>
cellRendererToggleGetActivatable :: (HasCallStack, MonadIO m, IsCellRendererToggle a) => a -> m Bool

-- | Returns whether the cell renderer is active. See
--   <a>cellRendererToggleSetActive</a>.
cellRendererToggleGetActive :: (HasCallStack, MonadIO m, IsCellRendererToggle a) => a -> m Bool

-- | Returns whether we’re rendering radio toggles rather than checkboxes.
cellRendererToggleGetRadio :: (HasCallStack, MonadIO m, IsCellRendererToggle a) => a -> m Bool

-- | Makes the cell renderer activatable.
--   
--   <i>Since: 2.18</i>
cellRendererToggleSetActivatable :: (HasCallStack, MonadIO m, IsCellRendererToggle a) => a -> Bool -> m ()

-- | Activates or deactivates a cell renderer.
cellRendererToggleSetActive :: (HasCallStack, MonadIO m, IsCellRendererToggle a) => a -> Bool -> m ()

-- | If <i><tt>radio</tt></i> is <a>True</a>, the cell renderer renders a
--   radio toggle (i.e. a toggle in a group of mutually-exclusive toggles).
--   If <a>False</a>, it renders a check toggle (a standalone boolean
--   option). This can be set globally for the cell renderer, or changed
--   just before rendering each cell in the model (for <a>TreeView</a>, you
--   set up a per-row setting using <a>TreeViewColumn</a> to associate
--   model columns with cell renderer properties).
cellRendererToggleSetRadio :: (HasCallStack, MonadIO m, IsCellRendererToggle a) => a -> Bool -> m ()

-- | Cast to <a>CellRendererText</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toCellRendererText :: (MonadIO m, IsCellRendererText o) => o -> m CellRendererText

-- | Connect a signal handler for the <a>edited</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellRendererText #edited callback
--   </pre>
onCellRendererTextEdited :: (IsCellRendererText a, MonadIO m) => a -> ((?self :: a) => CellRendererTextEditedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>edited</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellRendererText #edited callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellRendererTextEdited :: (IsCellRendererText a, MonadIO m) => a -> ((?self :: a) => CellRendererTextEditedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>align-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #alignSet
--   </pre>
getCellRendererTextAlignSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>align-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #alignSet <a>:=</a> value ]
--   </pre>
setCellRendererTextAlignSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>align-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextAlignSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>alignment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #alignment
--   </pre>
getCellRendererTextAlignment :: (MonadIO m, IsCellRendererText o) => o -> m Alignment

-- | Set the value of the “<tt>alignment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #alignment <a>:=</a> value ]
--   </pre>
setCellRendererTextAlignment :: (MonadIO m, IsCellRendererText o) => o -> Alignment -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>alignment</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextAlignment :: (IsCellRendererText o, MonadIO m) => Alignment -> m (GValueConstruct o)

-- | Get the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #attributes
--   </pre>
getCellRendererTextAttributes :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe AttrList)

-- | Set the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #attributes <a>:=</a> value ]
--   </pre>
setCellRendererTextAttributes :: (MonadIO m, IsCellRendererText o) => o -> AttrList -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>attributes</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextAttributes :: (IsCellRendererText o, MonadIO m) => AttrList -> m (GValueConstruct o)

-- | Set the value of the “<tt>attributes</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #attributes
--   </pre>
clearCellRendererTextAttributes :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Set the value of the “<tt>background</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #background <a>:=</a> value ]
--   </pre>
setCellRendererTextBackground :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextBackground :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>background</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #background
--   </pre>
clearCellRendererTextBackground :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “<tt>background-gdk</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #backgroundGdk
--   </pre>
getCellRendererTextBackgroundGdk :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Color)

-- | Set the value of the “<tt>background-gdk</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #backgroundGdk <a>:=</a> value ]
--   </pre>
setCellRendererTextBackgroundGdk :: (MonadIO m, IsCellRendererText o) => o -> Color -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-gdk</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererTextBackgroundGdk :: (IsCellRendererText o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Set the value of the “<tt>background-gdk</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #backgroundGdk
--   </pre>
clearCellRendererTextBackgroundGdk :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “<tt>background-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #backgroundRgba
--   </pre>
getCellRendererTextBackgroundRgba :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>background-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #backgroundRgba <a>:=</a> value ]
--   </pre>
setCellRendererTextBackgroundRgba :: (MonadIO m, IsCellRendererText o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-rgba</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererTextBackgroundRgba :: (IsCellRendererText o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “<tt>background-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #backgroundRgba
--   </pre>
clearCellRendererTextBackgroundRgba :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “<tt>background-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #backgroundSet
--   </pre>
getCellRendererTextBackgroundSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>background-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #backgroundSet <a>:=</a> value ]
--   </pre>
setCellRendererTextBackgroundSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererTextBackgroundSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>editable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #editable
--   </pre>
getCellRendererTextEditable :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>editable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #editable <a>:=</a> value ]
--   </pre>
setCellRendererTextEditable :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>editable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextEditable :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>editable-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #editableSet
--   </pre>
getCellRendererTextEditableSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>editable-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #editableSet <a>:=</a> value ]
--   </pre>
setCellRendererTextEditableSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>editable-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextEditableSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>ellipsize</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #ellipsize
--   </pre>
getCellRendererTextEllipsize :: (MonadIO m, IsCellRendererText o) => o -> m EllipsizeMode

-- | Set the value of the “<tt>ellipsize</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #ellipsize <a>:=</a> value ]
--   </pre>
setCellRendererTextEllipsize :: (MonadIO m, IsCellRendererText o) => o -> EllipsizeMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ellipsize</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextEllipsize :: (IsCellRendererText o, MonadIO m) => EllipsizeMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>ellipsize-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #ellipsizeSet
--   </pre>
getCellRendererTextEllipsizeSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>ellipsize-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #ellipsizeSet <a>:=</a> value ]
--   </pre>
setCellRendererTextEllipsizeSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ellipsize-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextEllipsizeSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>family</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #family
--   </pre>
getCellRendererTextFamily :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>family</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #family <a>:=</a> value ]
--   </pre>
setCellRendererTextFamily :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>family</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextFamily :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>family</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #family
--   </pre>
clearCellRendererTextFamily :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “<tt>family-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #familySet
--   </pre>
getCellRendererTextFamilySet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>family-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #familySet <a>:=</a> value ]
--   </pre>
setCellRendererTextFamilySet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>family-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextFamilySet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>font</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #font
--   </pre>
getCellRendererTextFont :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>font</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #font <a>:=</a> value ]
--   </pre>
setCellRendererTextFont :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextFont :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>font</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #font
--   </pre>
clearCellRendererTextFont :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “<tt>font-desc</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #fontDesc
--   </pre>
getCellRendererTextFontDesc :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe FontDescription)

-- | Set the value of the “<tt>font-desc</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #fontDesc <a>:=</a> value ]
--   </pre>
setCellRendererTextFontDesc :: (MonadIO m, IsCellRendererText o) => o -> FontDescription -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font-desc</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextFontDesc :: (IsCellRendererText o, MonadIO m) => FontDescription -> m (GValueConstruct o)

-- | Set the value of the “<tt>font-desc</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #fontDesc
--   </pre>
clearCellRendererTextFontDesc :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Set the value of the “<tt>foreground</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #foreground <a>:=</a> value ]
--   </pre>
setCellRendererTextForeground :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>foreground</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextForeground :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>foreground</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #foreground
--   </pre>
clearCellRendererTextForeground :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “<tt>foreground-gdk</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #foregroundGdk
--   </pre>
getCellRendererTextForegroundGdk :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Color)

-- | Set the value of the “<tt>foreground-gdk</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #foregroundGdk <a>:=</a> value ]
--   </pre>
setCellRendererTextForegroundGdk :: (MonadIO m, IsCellRendererText o) => o -> Color -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>foreground-gdk</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererTextForegroundGdk :: (IsCellRendererText o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Set the value of the “<tt>foreground-gdk</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #foregroundGdk
--   </pre>
clearCellRendererTextForegroundGdk :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “<tt>foreground-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #foregroundRgba
--   </pre>
getCellRendererTextForegroundRgba :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>foreground-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #foregroundRgba <a>:=</a> value ]
--   </pre>
setCellRendererTextForegroundRgba :: (MonadIO m, IsCellRendererText o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>foreground-rgba</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererTextForegroundRgba :: (IsCellRendererText o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “<tt>foreground-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #foregroundRgba
--   </pre>
clearCellRendererTextForegroundRgba :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “<tt>foreground-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #foregroundSet
--   </pre>
getCellRendererTextForegroundSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>foreground-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #foregroundSet <a>:=</a> value ]
--   </pre>
setCellRendererTextForegroundSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>foreground-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererTextForegroundSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>language</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #language
--   </pre>
getCellRendererTextLanguage :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>language</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #language <a>:=</a> value ]
--   </pre>
setCellRendererTextLanguage :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>language</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextLanguage :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>language</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #language
--   </pre>
clearCellRendererTextLanguage :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “<tt>language-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #languageSet
--   </pre>
getCellRendererTextLanguageSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>language-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #languageSet <a>:=</a> value ]
--   </pre>
setCellRendererTextLanguageSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>language-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextLanguageSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Set the value of the “<tt>markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #markup <a>:=</a> value ]
--   </pre>
setCellRendererTextMarkup :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>markup</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextMarkup :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>markup</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #markup
--   </pre>
clearCellRendererTextMarkup :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “<tt>max-width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #maxWidthChars
--   </pre>
getCellRendererTextMaxWidthChars :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “<tt>max-width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #maxWidthChars <a>:=</a> value ]
--   </pre>
setCellRendererTextMaxWidthChars :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-width-chars</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererTextMaxWidthChars :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>placeholder-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #placeholderText
--   </pre>
getCellRendererTextPlaceholderText :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>placeholder-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #placeholderText <a>:=</a> value ]
--   </pre>
setCellRendererTextPlaceholderText :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>placeholder-text</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererTextPlaceholderText :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>placeholder-text</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #placeholderText
--   </pre>
clearCellRendererTextPlaceholderText :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “<tt>rise</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #rise
--   </pre>
getCellRendererTextRise :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “<tt>rise</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #rise <a>:=</a> value ]
--   </pre>
setCellRendererTextRise :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rise</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextRise :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>rise-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #riseSet
--   </pre>
getCellRendererTextRiseSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>rise-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #riseSet <a>:=</a> value ]
--   </pre>
setCellRendererTextRiseSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rise-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextRiseSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>scale</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #scale
--   </pre>
getCellRendererTextScale :: (MonadIO m, IsCellRendererText o) => o -> m Double

-- | Set the value of the “<tt>scale</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #scale <a>:=</a> value ]
--   </pre>
setCellRendererTextScale :: (MonadIO m, IsCellRendererText o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>scale</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextScale :: (IsCellRendererText o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>scale-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #scaleSet
--   </pre>
getCellRendererTextScaleSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>scale-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #scaleSet <a>:=</a> value ]
--   </pre>
setCellRendererTextScaleSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>scale-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextScaleSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>single-paragraph-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #singleParagraphMode
--   </pre>
getCellRendererTextSingleParagraphMode :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>single-paragraph-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #singleParagraphMode <a>:=</a> value ]
--   </pre>
setCellRendererTextSingleParagraphMode :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>single-paragraph-mode</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCellRendererTextSingleParagraphMode :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #size
--   </pre>
getCellRendererTextSize :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #size <a>:=</a> value ]
--   </pre>
setCellRendererTextSize :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextSize :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>size-points</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #sizePoints
--   </pre>
getCellRendererTextSizePoints :: (MonadIO m, IsCellRendererText o) => o -> m Double

-- | Set the value of the “<tt>size-points</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #sizePoints <a>:=</a> value ]
--   </pre>
setCellRendererTextSizePoints :: (MonadIO m, IsCellRendererText o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size-points</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextSizePoints :: (IsCellRendererText o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>size-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #sizeSet
--   </pre>
getCellRendererTextSizeSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>size-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #sizeSet <a>:=</a> value ]
--   </pre>
setCellRendererTextSizeSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextSizeSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>stretch</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #stretch
--   </pre>
getCellRendererTextStretch :: (MonadIO m, IsCellRendererText o) => o -> m Stretch

-- | Set the value of the “<tt>stretch</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #stretch <a>:=</a> value ]
--   </pre>
setCellRendererTextStretch :: (MonadIO m, IsCellRendererText o) => o -> Stretch -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stretch</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextStretch :: (IsCellRendererText o, MonadIO m) => Stretch -> m (GValueConstruct o)

-- | Get the value of the “<tt>stretch-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #stretchSet
--   </pre>
getCellRendererTextStretchSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>stretch-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #stretchSet <a>:=</a> value ]
--   </pre>
setCellRendererTextStretchSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stretch-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextStretchSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>strikethrough</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #strikethrough
--   </pre>
getCellRendererTextStrikethrough :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>strikethrough</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #strikethrough <a>:=</a> value ]
--   </pre>
setCellRendererTextStrikethrough :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>strikethrough</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextStrikethrough :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>strikethrough-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #strikethroughSet
--   </pre>
getCellRendererTextStrikethroughSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>strikethrough-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #strikethroughSet <a>:=</a> value ]
--   </pre>
setCellRendererTextStrikethroughSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>strikethrough-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererTextStrikethroughSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #style
--   </pre>
getCellRendererTextStyle :: (MonadIO m, IsCellRendererText o) => o -> m Style

-- | Set the value of the “<tt>style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #style <a>:=</a> value ]
--   </pre>
setCellRendererTextStyle :: (MonadIO m, IsCellRendererText o) => o -> Style -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>style</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextStyle :: (IsCellRendererText o, MonadIO m) => Style -> m (GValueConstruct o)

-- | Get the value of the “<tt>style-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #styleSet
--   </pre>
getCellRendererTextStyleSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>style-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #styleSet <a>:=</a> value ]
--   </pre>
setCellRendererTextStyleSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>style-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextStyleSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #text
--   </pre>
getCellRendererTextText :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #text <a>:=</a> value ]
--   </pre>
setCellRendererTextText :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextText :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>text</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #text
--   </pre>
clearCellRendererTextText :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Get the value of the “<tt>underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #underline
--   </pre>
getCellRendererTextUnderline :: (MonadIO m, IsCellRendererText o) => o -> m Underline

-- | Set the value of the “<tt>underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #underline <a>:=</a> value ]
--   </pre>
setCellRendererTextUnderline :: (MonadIO m, IsCellRendererText o) => o -> Underline -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>underline</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextUnderline :: (IsCellRendererText o, MonadIO m) => Underline -> m (GValueConstruct o)

-- | Get the value of the “<tt>underline-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #underlineSet
--   </pre>
getCellRendererTextUnderlineSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>underline-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #underlineSet <a>:=</a> value ]
--   </pre>
setCellRendererTextUnderlineSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>underline-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextUnderlineSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>variant</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #variant
--   </pre>
getCellRendererTextVariant :: (MonadIO m, IsCellRendererText o) => o -> m Variant

-- | Set the value of the “<tt>variant</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #variant <a>:=</a> value ]
--   </pre>
setCellRendererTextVariant :: (MonadIO m, IsCellRendererText o) => o -> Variant -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>variant</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextVariant :: (IsCellRendererText o, MonadIO m) => Variant -> m (GValueConstruct o)

-- | Get the value of the “<tt>variant-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #variantSet
--   </pre>
getCellRendererTextVariantSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>variant-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #variantSet <a>:=</a> value ]
--   </pre>
setCellRendererTextVariantSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>variant-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextVariantSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>weight</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #weight
--   </pre>
getCellRendererTextWeight :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “<tt>weight</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #weight <a>:=</a> value ]
--   </pre>
setCellRendererTextWeight :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>weight</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextWeight :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>weight-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #weightSet
--   </pre>
getCellRendererTextWeightSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>weight-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #weightSet <a>:=</a> value ]
--   </pre>
setCellRendererTextWeightSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>weight-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextWeightSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #widthChars
--   </pre>
getCellRendererTextWidthChars :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “<tt>width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #widthChars <a>:=</a> value ]
--   </pre>
setCellRendererTextWidthChars :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>width-chars</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextWidthChars :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #wrapMode
--   </pre>
getCellRendererTextWrapMode :: (MonadIO m, IsCellRendererText o) => o -> m WrapMode

-- | Set the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #wrapMode <a>:=</a> value ]
--   </pre>
setCellRendererTextWrapMode :: (MonadIO m, IsCellRendererText o) => o -> WrapMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap-mode</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextWrapMode :: (IsCellRendererText o, MonadIO m) => WrapMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #wrapWidth
--   </pre>
getCellRendererTextWrapWidth :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “<tt>wrap-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #wrapWidth <a>:=</a> value ]
--   </pre>
setCellRendererTextWrapWidth :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap-width</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextWrapWidth :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new <a>CellRendererText</a>. Adjust how text is drawn using
--   object properties. Object properties can be set globally (with
--   <tt><i>g_object_set()</i></tt>). Also, with <a>TreeViewColumn</a>, you
--   can bind a property to a value in a <a>TreeModel</a>. For example, you
--   can bind the “text” property on the cell renderer to a string value in
--   the model, thus rendering a different string in each row of the
--   <a>TreeView</a>
cellRendererTextNew :: (HasCallStack, MonadIO m) => m CellRendererText

-- | Sets the height of a renderer to explicitly be determined by the
--   “font” and “y_pad” property set on it. Further changes in these
--   properties do not affect the height, so they must be accompanied by a
--   subsequent call to this function. Using this function is unflexible,
--   and should really only be used if calculating the size of a cell is
--   too slow (ie, a massive number of cells displayed). If
--   <i><tt>numberOfRows</tt></i> is -1, then the fixed height is unset,
--   and the height is determined by the properties again.
cellRendererTextSetFixedHeightFromFont :: (HasCallStack, MonadIO m, IsCellRendererText a) => a -> Int32 -> m ()

-- | Cast to <a>CellRendererSpinner</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toCellRendererSpinner :: (MonadIO m, IsCellRendererSpinner o) => o -> m CellRendererSpinner

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererSpinner #active
--   </pre>
getCellRendererSpinnerActive :: (MonadIO m, IsCellRendererSpinner o) => o -> m Bool

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererSpinner [ #active <a>:=</a> value ]
--   </pre>
setCellRendererSpinnerActive :: (MonadIO m, IsCellRendererSpinner o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererSpinnerActive :: (IsCellRendererSpinner o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>pulse</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererSpinner #pulse
--   </pre>
getCellRendererSpinnerPulse :: (MonadIO m, IsCellRendererSpinner o) => o -> m Word32

-- | Set the value of the “<tt>pulse</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererSpinner [ #pulse <a>:=</a> value ]
--   </pre>
setCellRendererSpinnerPulse :: (MonadIO m, IsCellRendererSpinner o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pulse</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererSpinnerPulse :: (IsCellRendererSpinner o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererSpinner #size
--   </pre>
getCellRendererSpinnerSize :: (MonadIO m, IsCellRendererSpinner o) => o -> m IconSize

-- | Set the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererSpinner [ #size <a>:=</a> value ]
--   </pre>
setCellRendererSpinnerSize :: (MonadIO m, IsCellRendererSpinner o) => o -> IconSize -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererSpinnerSize :: (IsCellRendererSpinner o, MonadIO m) => IconSize -> m (GValueConstruct o)

-- | Returns a new cell renderer which will show a spinner to indicate
--   activity.
--   
--   <i>Since: 2.20</i>
cellRendererSpinnerNew :: (HasCallStack, MonadIO m) => m CellRendererSpinner

-- | Cast to <a>CellRendererSpin</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toCellRendererSpin :: (MonadIO m, IsCellRendererSpin o) => o -> m CellRendererSpin

-- | Get the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererSpin #adjustment
--   </pre>
getCellRendererSpinAdjustment :: (MonadIO m, IsCellRendererSpin o) => o -> m (Maybe Adjustment)

-- | Set the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererSpin [ #adjustment <a>:=</a> value ]
--   </pre>
setCellRendererSpinAdjustment :: (MonadIO m, IsCellRendererSpin o, IsAdjustment a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>adjustment</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererSpinAdjustment :: (IsCellRendererSpin o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>adjustment</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #adjustment
--   </pre>
clearCellRendererSpinAdjustment :: (MonadIO m, IsCellRendererSpin o) => o -> m ()

-- | Get the value of the “<tt>climb-rate</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererSpin #climbRate
--   </pre>
getCellRendererSpinClimbRate :: (MonadIO m, IsCellRendererSpin o) => o -> m Double

-- | Set the value of the “<tt>climb-rate</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererSpin [ #climbRate <a>:=</a> value ]
--   </pre>
setCellRendererSpinClimbRate :: (MonadIO m, IsCellRendererSpin o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>climb-rate</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererSpinClimbRate :: (IsCellRendererSpin o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>digits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererSpin #digits
--   </pre>
getCellRendererSpinDigits :: (MonadIO m, IsCellRendererSpin o) => o -> m Word32

-- | Set the value of the “<tt>digits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererSpin [ #digits <a>:=</a> value ]
--   </pre>
setCellRendererSpinDigits :: (MonadIO m, IsCellRendererSpin o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>digits</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererSpinDigits :: (IsCellRendererSpin o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Creates a new <a>CellRendererSpin</a>.
--   
--   <i>Since: 2.10</i>
cellRendererSpinNew :: (HasCallStack, MonadIO m) => m CellRendererSpin

-- | Cast to <a>CellRendererProgress</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toCellRendererProgress :: (MonadIO m, IsCellRendererProgress o) => o -> m CellRendererProgress

-- | Get the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererProgress #inverted
--   </pre>
getCellRendererProgressInverted :: (MonadIO m, IsCellRendererProgress o) => o -> m Bool

-- | Set the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererProgress [ #inverted <a>:=</a> value ]
--   </pre>
setCellRendererProgressInverted :: (MonadIO m, IsCellRendererProgress o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inverted</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererProgressInverted :: (IsCellRendererProgress o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>pulse</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererProgress #pulse
--   </pre>
getCellRendererProgressPulse :: (MonadIO m, IsCellRendererProgress o) => o -> m Int32

-- | Set the value of the “<tt>pulse</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererProgress [ #pulse <a>:=</a> value ]
--   </pre>
setCellRendererProgressPulse :: (MonadIO m, IsCellRendererProgress o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pulse</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererProgressPulse :: (IsCellRendererProgress o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererProgress #text
--   </pre>
getCellRendererProgressText :: (MonadIO m, IsCellRendererProgress o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererProgress [ #text <a>:=</a> value ]
--   </pre>
setCellRendererProgressText :: (MonadIO m, IsCellRendererProgress o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererProgressText :: (IsCellRendererProgress o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>text</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #text
--   </pre>
clearCellRendererProgressText :: (MonadIO m, IsCellRendererProgress o) => o -> m ()

-- | Get the value of the “<tt>text-xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererProgress #textXalign
--   </pre>
getCellRendererProgressTextXalign :: (MonadIO m, IsCellRendererProgress o) => o -> m Float

-- | Set the value of the “<tt>text-xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererProgress [ #textXalign <a>:=</a> value ]
--   </pre>
setCellRendererProgressTextXalign :: (MonadIO m, IsCellRendererProgress o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-xalign</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererProgressTextXalign :: (IsCellRendererProgress o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>text-yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererProgress #textYalign
--   </pre>
getCellRendererProgressTextYalign :: (MonadIO m, IsCellRendererProgress o) => o -> m Float

-- | Set the value of the “<tt>text-yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererProgress [ #textYalign <a>:=</a> value ]
--   </pre>
setCellRendererProgressTextYalign :: (MonadIO m, IsCellRendererProgress o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-yalign</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererProgressTextYalign :: (IsCellRendererProgress o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererProgress #value
--   </pre>
getCellRendererProgressValue :: (MonadIO m, IsCellRendererProgress o) => o -> m Int32

-- | Set the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererProgress [ #value <a>:=</a> value ]
--   </pre>
setCellRendererProgressValue :: (MonadIO m, IsCellRendererProgress o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>value</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererProgressValue :: (IsCellRendererProgress o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new <a>CellRendererProgress</a>.
--   
--   <i>Since: 2.6</i>
cellRendererProgressNew :: (HasCallStack, MonadIO m) => m CellRendererProgress

-- | Cast to <a>CellRendererPixbuf</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toCellRendererPixbuf :: (MonadIO m, IsCellRendererPixbuf o) => o -> m CellRendererPixbuf

-- | Get the value of the “<tt>follow-state</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererPixbuf #followState
--   </pre>
getCellRendererPixbufFollowState :: (MonadIO m, IsCellRendererPixbuf o) => o -> m Bool

-- | Set the value of the “<tt>follow-state</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #followState <a>:=</a> value ]
--   </pre>
setCellRendererPixbufFollowState :: (MonadIO m, IsCellRendererPixbuf o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>follow-state</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererPixbufFollowState :: (IsCellRendererPixbuf o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererPixbuf #gicon
--   </pre>
getCellRendererPixbufGicon :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Icon)

-- | Set the value of the “<tt>gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #gicon <a>:=</a> value ]
--   </pre>
setCellRendererPixbufGicon :: (MonadIO m, IsCellRendererPixbuf o, IsIcon a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gicon</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererPixbufGicon :: (IsCellRendererPixbuf o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>gicon</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #gicon
--   </pre>
clearCellRendererPixbufGicon :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Get the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererPixbuf #iconName
--   </pre>
getCellRendererPixbufIconName :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #iconName <a>:=</a> value ]
--   </pre>
setCellRendererPixbufIconName :: (MonadIO m, IsCellRendererPixbuf o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererPixbufIconName :: (IsCellRendererPixbuf o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>icon-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #iconName
--   </pre>
clearCellRendererPixbufIconName :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Get the value of the “<tt>pixbuf</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererPixbuf #pixbuf
--   </pre>
getCellRendererPixbufPixbuf :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “<tt>pixbuf</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #pixbuf <a>:=</a> value ]
--   </pre>
setCellRendererPixbufPixbuf :: (MonadIO m, IsCellRendererPixbuf o, IsPixbuf a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixbuf</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererPixbufPixbuf :: (IsCellRendererPixbuf o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>pixbuf</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #pixbuf
--   </pre>
clearCellRendererPixbufPixbuf :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Get the value of the “<tt>pixbuf-expander-closed</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererPixbuf #pixbufExpanderClosed
--   </pre>
getCellRendererPixbufPixbufExpanderClosed :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “<tt>pixbuf-expander-closed</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #pixbufExpanderClosed <a>:=</a> value ]
--   </pre>
setCellRendererPixbufPixbufExpanderClosed :: (MonadIO m, IsCellRendererPixbuf o, IsPixbuf a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixbuf-expander-closed</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCellRendererPixbufPixbufExpanderClosed :: (IsCellRendererPixbuf o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>pixbuf-expander-closed</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #pixbufExpanderClosed
--   </pre>
clearCellRendererPixbufPixbufExpanderClosed :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Get the value of the “<tt>pixbuf-expander-open</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererPixbuf #pixbufExpanderOpen
--   </pre>
getCellRendererPixbufPixbufExpanderOpen :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “<tt>pixbuf-expander-open</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #pixbufExpanderOpen <a>:=</a> value ]
--   </pre>
setCellRendererPixbufPixbufExpanderOpen :: (MonadIO m, IsCellRendererPixbuf o, IsPixbuf a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixbuf-expander-open</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCellRendererPixbufPixbufExpanderOpen :: (IsCellRendererPixbuf o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>pixbuf-expander-open</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #pixbufExpanderOpen
--   </pre>
clearCellRendererPixbufPixbufExpanderOpen :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Get the value of the “<tt>stock-detail</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererPixbuf #stockDetail
--   </pre>
getCellRendererPixbufStockDetail :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>stock-detail</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #stockDetail <a>:=</a> value ]
--   </pre>
setCellRendererPixbufStockDetail :: (MonadIO m, IsCellRendererPixbuf o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stock-detail</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererPixbufStockDetail :: (IsCellRendererPixbuf o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>stock-detail</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #stockDetail
--   </pre>
clearCellRendererPixbufStockDetail :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Get the value of the “<tt>stock-id</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererPixbuf #stockId
--   </pre>
getCellRendererPixbufStockId :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>stock-id</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #stockId <a>:=</a> value ]
--   </pre>
setCellRendererPixbufStockId :: (MonadIO m, IsCellRendererPixbuf o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stock-id</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererPixbufStockId :: (IsCellRendererPixbuf o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>stock-id</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #stockId
--   </pre>
clearCellRendererPixbufStockId :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Get the value of the “<tt>stock-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererPixbuf #stockSize
--   </pre>
getCellRendererPixbufStockSize :: (MonadIO m, IsCellRendererPixbuf o) => o -> m Word32

-- | Set the value of the “<tt>stock-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #stockSize <a>:=</a> value ]
--   </pre>
setCellRendererPixbufStockSize :: (MonadIO m, IsCellRendererPixbuf o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stock-size</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererPixbufStockSize :: (IsCellRendererPixbuf o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>surface</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererPixbuf #surface
--   </pre>
getCellRendererPixbufSurface :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Surface)

-- | Set the value of the “<tt>surface</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #surface <a>:=</a> value ]
--   </pre>
setCellRendererPixbufSurface :: (MonadIO m, IsCellRendererPixbuf o) => o -> Surface -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>surface</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererPixbufSurface :: (IsCellRendererPixbuf o, MonadIO m) => Surface -> m (GValueConstruct o)

-- | Set the value of the “<tt>surface</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #surface
--   </pre>
clearCellRendererPixbufSurface :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Creates a new <a>CellRendererPixbuf</a>. Adjust rendering parameters
--   using object properties. Object properties can be set globally (with
--   <tt><i>g_object_set()</i></tt>). Also, with <a>TreeViewColumn</a>, you
--   can bind a property to a value in a <a>TreeModel</a>. For example, you
--   can bind the “pixbuf” property on the cell renderer to a pixbuf value
--   in the model, thus rendering a different image in each row of the
--   <a>TreeView</a>.
cellRendererPixbufNew :: (HasCallStack, MonadIO m) => m CellRendererPixbuf

-- | Cast to <a>CellRendererCombo</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toCellRendererCombo :: (MonadIO m, IsCellRendererCombo o) => o -> m CellRendererCombo

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellRendererCombo #changed callback
--   </pre>
onCellRendererComboChanged :: (IsCellRendererCombo a, MonadIO m) => a -> ((?self :: a) => CellRendererComboChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellRendererCombo #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellRendererComboChanged :: (IsCellRendererCombo a, MonadIO m) => a -> ((?self :: a) => CellRendererComboChangedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>has-entry</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererCombo #hasEntry
--   </pre>
getCellRendererComboHasEntry :: (MonadIO m, IsCellRendererCombo o) => o -> m Bool

-- | Set the value of the “<tt>has-entry</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererCombo [ #hasEntry <a>:=</a> value ]
--   </pre>
setCellRendererComboHasEntry :: (MonadIO m, IsCellRendererCombo o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-entry</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererComboHasEntry :: (IsCellRendererCombo o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererCombo #model
--   </pre>
getCellRendererComboModel :: (MonadIO m, IsCellRendererCombo o) => o -> m (Maybe TreeModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererCombo [ #model <a>:=</a> value ]
--   </pre>
setCellRendererComboModel :: (MonadIO m, IsCellRendererCombo o, IsTreeModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererComboModel :: (IsCellRendererCombo o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearCellRendererComboModel :: (MonadIO m, IsCellRendererCombo o) => o -> m ()

-- | Get the value of the “<tt>text-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererCombo #textColumn
--   </pre>
getCellRendererComboTextColumn :: (MonadIO m, IsCellRendererCombo o) => o -> m Int32

-- | Set the value of the “<tt>text-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererCombo [ #textColumn <a>:=</a> value ]
--   </pre>
setCellRendererComboTextColumn :: (MonadIO m, IsCellRendererCombo o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-column</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererComboTextColumn :: (IsCellRendererCombo o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new <a>CellRendererCombo</a>. Adjust how text is drawn using
--   object properties. Object properties can be set globally (with
--   <tt><i>g_object_set()</i></tt>). Also, with <a>TreeViewColumn</a>, you
--   can bind a property to a value in a <a>TreeModel</a>. For example, you
--   can bind the “text” property on the cell renderer to a string value in
--   the model, thus rendering a different string in each row of the
--   <a>TreeView</a>.
--   
--   <i>Since: 2.6</i>
cellRendererComboNew :: (HasCallStack, MonadIO m) => m CellRendererCombo

-- | Cast to <a>CellRendererAccel</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toCellRendererAccel :: (MonadIO m, IsCellRendererAccel o) => o -> m CellRendererAccel

-- | Connect a signal handler for the <a>accelCleared</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellRendererAccel #accelCleared callback
--   </pre>
onCellRendererAccelAccelCleared :: (IsCellRendererAccel a, MonadIO m) => a -> ((?self :: a) => CellRendererAccelAccelClearedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>accelCleared</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellRendererAccel #accelCleared callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellRendererAccelAccelCleared :: (IsCellRendererAccel a, MonadIO m) => a -> ((?self :: a) => CellRendererAccelAccelClearedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>accelEdited</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellRendererAccel #accelEdited callback
--   </pre>
onCellRendererAccelAccelEdited :: (IsCellRendererAccel a, MonadIO m) => a -> ((?self :: a) => CellRendererAccelAccelEditedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>accelEdited</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellRendererAccel #accelEdited callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellRendererAccelAccelEdited :: (IsCellRendererAccel a, MonadIO m) => a -> ((?self :: a) => CellRendererAccelAccelEditedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>accel-key</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererAccel #accelKey
--   </pre>
getCellRendererAccelAccelKey :: (MonadIO m, IsCellRendererAccel o) => o -> m Word32

-- | Set the value of the “<tt>accel-key</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererAccel [ #accelKey <a>:=</a> value ]
--   </pre>
setCellRendererAccelAccelKey :: (MonadIO m, IsCellRendererAccel o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-key</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererAccelAccelKey :: (IsCellRendererAccel o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>accel-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererAccel #accelMode
--   </pre>
getCellRendererAccelAccelMode :: (MonadIO m, IsCellRendererAccel o) => o -> m CellRendererAccelMode

-- | Set the value of the “<tt>accel-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererAccel [ #accelMode <a>:=</a> value ]
--   </pre>
setCellRendererAccelAccelMode :: (MonadIO m, IsCellRendererAccel o) => o -> CellRendererAccelMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-mode</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererAccelAccelMode :: (IsCellRendererAccel o, MonadIO m) => CellRendererAccelMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>accel-mods</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererAccel #accelMods
--   </pre>
getCellRendererAccelAccelMods :: (MonadIO m, IsCellRendererAccel o) => o -> m [ModifierType]

-- | Set the value of the “<tt>accel-mods</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererAccel [ #accelMods <a>:=</a> value ]
--   </pre>
setCellRendererAccelAccelMods :: (MonadIO m, IsCellRendererAccel o) => o -> [ModifierType] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-mods</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererAccelAccelMods :: (IsCellRendererAccel o, MonadIO m) => [ModifierType] -> m (GValueConstruct o)

-- | Get the value of the “<tt>keycode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererAccel #keycode
--   </pre>
getCellRendererAccelKeycode :: (MonadIO m, IsCellRendererAccel o) => o -> m Word32

-- | Set the value of the “<tt>keycode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererAccel [ #keycode <a>:=</a> value ]
--   </pre>
setCellRendererAccelKeycode :: (MonadIO m, IsCellRendererAccel o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>keycode</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererAccelKeycode :: (IsCellRendererAccel o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Creates a new <a>CellRendererAccel</a>.
--   
--   <i>Since: 2.10</i>
cellRendererAccelNew :: (HasCallStack, MonadIO m) => m CellRendererAccel

-- | Cast to <a>BooleanCellAccessible</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toBooleanCellAccessible :: (MonadIO m, IsBooleanCellAccessible o) => o -> m BooleanCellAccessible

-- | Cast to <a>SpinButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSpinButton :: (MonadIO m, IsSpinButton o) => o -> m SpinButton

-- | Connect a signal handler for the <a>changeValue</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> spinButton #changeValue callback
--   </pre>
onSpinButtonChangeValue :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonChangeValueCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changeValue</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> spinButton #changeValue callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSpinButtonChangeValue :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonChangeValueCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>input</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> spinButton #input callback
--   </pre>
onSpinButtonInput :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonInputCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>input</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> spinButton #input callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSpinButtonInput :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonInputCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>output</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> spinButton #output callback
--   </pre>
onSpinButtonOutput :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonOutputCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>output</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> spinButton #output callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSpinButtonOutput :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonOutputCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>valueChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> spinButton #valueChanged callback
--   </pre>
onSpinButtonValueChanged :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonValueChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>valueChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> spinButton #valueChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSpinButtonValueChanged :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonValueChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>wrapped</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> spinButton #wrapped callback
--   </pre>
onSpinButtonWrapped :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonWrappedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>wrapped</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> spinButton #wrapped callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSpinButtonWrapped :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonWrappedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #adjustment
--   </pre>
getSpinButtonAdjustment :: (MonadIO m, IsSpinButton o) => o -> m Adjustment

-- | Set the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #adjustment <a>:=</a> value ]
--   </pre>
setSpinButtonAdjustment :: (MonadIO m, IsSpinButton o, IsAdjustment a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>adjustment</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructSpinButtonAdjustment :: (IsSpinButton o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>climb-rate</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #climbRate
--   </pre>
getSpinButtonClimbRate :: (MonadIO m, IsSpinButton o) => o -> m Double

-- | Set the value of the “<tt>climb-rate</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #climbRate <a>:=</a> value ]
--   </pre>
setSpinButtonClimbRate :: (MonadIO m, IsSpinButton o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>climb-rate</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructSpinButtonClimbRate :: (IsSpinButton o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>digits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #digits
--   </pre>
getSpinButtonDigits :: (MonadIO m, IsSpinButton o) => o -> m Word32

-- | Set the value of the “<tt>digits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #digits <a>:=</a> value ]
--   </pre>
setSpinButtonDigits :: (MonadIO m, IsSpinButton o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>digits</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSpinButtonDigits :: (IsSpinButton o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>numeric</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #numeric
--   </pre>
getSpinButtonNumeric :: (MonadIO m, IsSpinButton o) => o -> m Bool

-- | Set the value of the “<tt>numeric</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #numeric <a>:=</a> value ]
--   </pre>
setSpinButtonNumeric :: (MonadIO m, IsSpinButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>numeric</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSpinButtonNumeric :: (IsSpinButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>snap-to-ticks</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #snapToTicks
--   </pre>
getSpinButtonSnapToTicks :: (MonadIO m, IsSpinButton o) => o -> m Bool

-- | Set the value of the “<tt>snap-to-ticks</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #snapToTicks <a>:=</a> value ]
--   </pre>
setSpinButtonSnapToTicks :: (MonadIO m, IsSpinButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>snap-to-ticks</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSpinButtonSnapToTicks :: (IsSpinButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>update-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #updatePolicy
--   </pre>
getSpinButtonUpdatePolicy :: (MonadIO m, IsSpinButton o) => o -> m SpinButtonUpdatePolicy

-- | Set the value of the “<tt>update-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #updatePolicy <a>:=</a> value ]
--   </pre>
setSpinButtonUpdatePolicy :: (MonadIO m, IsSpinButton o) => o -> SpinButtonUpdatePolicy -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>update-policy</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSpinButtonUpdatePolicy :: (IsSpinButton o, MonadIO m) => SpinButtonUpdatePolicy -> m (GValueConstruct o)

-- | Get the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #value
--   </pre>
getSpinButtonValue :: (MonadIO m, IsSpinButton o) => o -> m Double

-- | Set the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #value <a>:=</a> value ]
--   </pre>
setSpinButtonValue :: (MonadIO m, IsSpinButton o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>value</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSpinButtonValue :: (IsSpinButton o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #wrap
--   </pre>
getSpinButtonWrap :: (MonadIO m, IsSpinButton o) => o -> m Bool

-- | Set the value of the “<tt>wrap</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #wrap <a>:=</a> value ]
--   </pre>
setSpinButtonWrap :: (MonadIO m, IsSpinButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSpinButtonWrap :: (IsSpinButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>SpinButton</a>.
spinButtonNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe a -> Double -> Word32 -> m SpinButton

-- | This is a convenience constructor that allows creation of a numeric
--   <a>SpinButton</a> without manually creating an adjustment. The value
--   is initially set to the minimum value and a page increment of 10 *
--   <i><tt>step</tt></i> is the default. The precision of the spin button
--   is equivalent to the precision of <i><tt>step</tt></i>.
--   
--   Note that the way in which the precision is derived works best if
--   <i><tt>step</tt></i> is a power of ten. If the resulting precision is
--   not suitable for your needs, use <a>spinButtonSetDigits</a> to correct
--   it.
spinButtonNewWithRange :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> m SpinButton

-- | Changes the properties of an existing spin button. The adjustment,
--   climb rate, and number of decimal places are updated accordingly.
spinButtonConfigure :: (HasCallStack, MonadIO m, IsSpinButton a, IsAdjustment b) => a -> Maybe b -> Double -> Word32 -> m ()

-- | Get the adjustment associated with a <a>SpinButton</a>
spinButtonGetAdjustment :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Adjustment

-- | Fetches the precision of <i><tt>spinButton</tt></i>. See
--   <a>spinButtonSetDigits</a>.
spinButtonGetDigits :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Word32

-- | Gets the current step and page the increments used by
--   <i><tt>spinButton</tt></i>. See <a>spinButtonSetIncrements</a>.
spinButtonGetIncrements :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m (Double, Double)

-- | Returns whether non-numeric text can be typed into the spin button.
--   See <a>spinButtonSetNumeric</a>.
spinButtonGetNumeric :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Bool

-- | Gets the range allowed for <i><tt>spinButton</tt></i>. See
--   <a>spinButtonSetRange</a>.
spinButtonGetRange :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m (Double, Double)

-- | Returns whether the values are corrected to the nearest step. See
--   <a>spinButtonSetSnapToTicks</a>.
spinButtonGetSnapToTicks :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Bool

-- | Gets the update behavior of a spin button. See
--   <a>spinButtonSetUpdatePolicy</a>.
spinButtonGetUpdatePolicy :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m SpinButtonUpdatePolicy

-- | Get the value in the <i><tt>spinButton</tt></i>.
spinButtonGetValue :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Double

-- | Get the value <i><tt>spinButton</tt></i> represented as an integer.
spinButtonGetValueAsInt :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Int32

-- | Returns whether the spin button’s value wraps around to the opposite
--   limit when the upper or lower limit of the range is exceeded. See
--   <a>spinButtonSetWrap</a>.
spinButtonGetWrap :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Bool

-- | Replaces the <a>Adjustment</a> associated with
--   <i><tt>spinButton</tt></i>.
spinButtonSetAdjustment :: (HasCallStack, MonadIO m, IsSpinButton a, IsAdjustment b) => a -> b -> m ()

-- | Set the precision to be displayed by <i><tt>spinButton</tt></i>. Up to
--   20 digit precision is allowed.
spinButtonSetDigits :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Word32 -> m ()

-- | Sets the step and page increments for spin_button. This affects how
--   quickly the value changes when the spin button’s arrows are activated.
spinButtonSetIncrements :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Double -> Double -> m ()

-- | Sets the flag that determines if non-numeric text can be typed into
--   the spin button.
spinButtonSetNumeric :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Bool -> m ()

-- | Sets the minimum and maximum allowable values for
--   <i><tt>spinButton</tt></i>.
--   
--   If the current value is outside this range, it will be adjusted to fit
--   within the range, otherwise it will remain unchanged.
spinButtonSetRange :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Double -> Double -> m ()

-- | Sets the policy as to whether values are corrected to the nearest step
--   increment when a spin button is activated after providing an invalid
--   value.
spinButtonSetSnapToTicks :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Bool -> m ()

-- | Sets the value of <i><tt>spinButton</tt></i>.
spinButtonSetValue :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Double -> m ()

-- | Sets the flag that determines if a spin button value wraps around to
--   the opposite limit when the upper or lower limit of the range is
--   exceeded.
spinButtonSetWrap :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Bool -> m ()

-- | Manually force an update of the spin button.
spinButtonUpdate :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m ()

-- | Cast to <a>SearchEntry</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSearchEntry :: (MonadIO m, IsSearchEntry o) => o -> m SearchEntry

-- | Connect a signal handler for the <a>nextMatch</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> searchEntry #nextMatch callback
--   </pre>
onSearchEntryNextMatch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryNextMatchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>nextMatch</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> searchEntry #nextMatch callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSearchEntryNextMatch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryNextMatchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>previousMatch</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> searchEntry #previousMatch callback
--   </pre>
onSearchEntryPreviousMatch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryPreviousMatchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>previousMatch</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> searchEntry #previousMatch callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSearchEntryPreviousMatch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryPreviousMatchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>searchChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> searchEntry #searchChanged callback
--   </pre>
onSearchEntrySearchChanged :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntrySearchChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>searchChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> searchEntry #searchChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSearchEntrySearchChanged :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntrySearchChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>stopSearch</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> searchEntry #stopSearch callback
--   </pre>
onSearchEntryStopSearch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryStopSearchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>stopSearch</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> searchEntry #stopSearch callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSearchEntryStopSearch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryStopSearchCallback) -> m SignalHandlerId

-- | Creates a <a>SearchEntry</a>, with a find icon when the search field
--   is empty, and a clear icon when it isn't.
--   
--   <i>Since: 3.6</i>
searchEntryNew :: (HasCallStack, MonadIO m) => m SearchEntry

-- | This function should be called when the top-level window which
--   contains the search entry received a key event. If the entry is part
--   of a <a>SearchBar</a>, it is preferable to call
--   <a>searchBarHandleEvent</a> instead, which will reveal the entry in
--   addition to passing the event to this function.
--   
--   If the key event is handled by the search entry and starts or
--   continues a search, <a>EVENT_STOP</a> will be returned. The caller
--   should ensure that the entry is shown in this case, and not propagate
--   the event further.
--   
--   <i>Since: 3.16</i>
searchEntryHandleEvent :: (HasCallStack, MonadIO m, IsSearchEntry a) => a -> Event -> m Bool

-- | Cast to <a>SearchBar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSearchBar :: (MonadIO m, IsSearchBar o) => o -> m SearchBar

-- | Get the value of the “<tt>search-mode-enabled</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> searchBar #searchModeEnabled
--   </pre>
getSearchBarSearchModeEnabled :: (MonadIO m, IsSearchBar o) => o -> m Bool

-- | Set the value of the “<tt>search-mode-enabled</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> searchBar [ #searchModeEnabled <a>:=</a> value ]
--   </pre>
setSearchBarSearchModeEnabled :: (MonadIO m, IsSearchBar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>search-mode-enabled</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSearchBarSearchModeEnabled :: (IsSearchBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-close-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> searchBar #showCloseButton
--   </pre>
getSearchBarShowCloseButton :: (MonadIO m, IsSearchBar o) => o -> m Bool

-- | Set the value of the “<tt>show-close-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> searchBar [ #showCloseButton <a>:=</a> value ]
--   </pre>
setSearchBarShowCloseButton :: (MonadIO m, IsSearchBar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-close-button</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSearchBarShowCloseButton :: (IsSearchBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a <a>SearchBar</a>. You will need to tell it about which
--   widget is going to be your text entry using
--   <a>searchBarConnectEntry</a>.
--   
--   <i>Since: 3.10</i>
searchBarNew :: (HasCallStack, MonadIO m) => m SearchBar

-- | Connects the <a>Entry</a> widget passed as the one to be used in this
--   search bar. The entry should be a descendant of the search bar. This
--   is only required if the entry isn’t the direct child of the search bar
--   (as in our main example).
--   
--   <i>Since: 3.10</i>
searchBarConnectEntry :: (HasCallStack, MonadIO m, IsSearchBar a, IsEntry b) => a -> b -> m ()

-- | Returns whether the search mode is on or off.
--   
--   <i>Since: 3.10</i>
searchBarGetSearchMode :: (HasCallStack, MonadIO m, IsSearchBar a) => a -> m Bool

-- | Returns whether the close button is shown.
--   
--   <i>Since: 3.10</i>
searchBarGetShowCloseButton :: (HasCallStack, MonadIO m, IsSearchBar a) => a -> m Bool

-- | Switches the search mode on or off.
--   
--   <i>Since: 3.10</i>
searchBarSetSearchMode :: (HasCallStack, MonadIO m, IsSearchBar a) => a -> Bool -> m ()

-- | Shows or hides the close button. Applications that already have a
--   “search” toggle button should not show a close button in their search
--   bar, as it duplicates the role of the toggle button.
--   
--   <i>Since: 3.10</i>
searchBarSetShowCloseButton :: (HasCallStack, MonadIO m, IsSearchBar a) => a -> Bool -> m ()

-- | Cast to <a>ComboBox</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toComboBox :: (MonadIO m, IsComboBox o) => o -> m ComboBox

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> comboBox #changed callback
--   </pre>
onComboBoxChanged :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> comboBox #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterComboBoxChanged :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>formatEntryText</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> comboBox #formatEntryText callback
--   </pre>
onComboBoxFormatEntryText :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxFormatEntryTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>formatEntryText</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> comboBox #formatEntryText callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterComboBoxFormatEntryText :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxFormatEntryTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveActive</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> comboBox #moveActive callback
--   </pre>
onComboBoxMoveActive :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxMoveActiveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveActive</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> comboBox #moveActive callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterComboBoxMoveActive :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxMoveActiveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popdown</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> comboBox #popdown callback
--   </pre>
onComboBoxPopdown :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxPopdownCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popdown</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> comboBox #popdown callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterComboBoxPopdown :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxPopdownCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popup</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> comboBox #popup callback
--   </pre>
onComboBoxPopup :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxPopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popup</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> comboBox #popup callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterComboBoxPopup :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxPopupCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #active
--   </pre>
getComboBoxActive :: (MonadIO m, IsComboBox o) => o -> m Int32

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #active <a>:=</a> value ]
--   </pre>
setComboBoxActive :: (MonadIO m, IsComboBox o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructComboBoxActive :: (IsComboBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>active-id</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #activeId
--   </pre>
getComboBoxActiveId :: (MonadIO m, IsComboBox o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>active-id</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #activeId <a>:=</a> value ]
--   </pre>
setComboBoxActiveId :: (MonadIO m, IsComboBox o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active-id</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructComboBoxActiveId :: (IsComboBox o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>active-id</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #activeId
--   </pre>
clearComboBoxActiveId :: (MonadIO m, IsComboBox o) => o -> m ()

-- | Get the value of the “<tt>add-tearoffs</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #addTearoffs
--   </pre>
getComboBoxAddTearoffs :: (MonadIO m, IsComboBox o) => o -> m Bool

-- | Set the value of the “<tt>add-tearoffs</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #addTearoffs <a>:=</a> value ]
--   </pre>
setComboBoxAddTearoffs :: (MonadIO m, IsComboBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>add-tearoffs</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructComboBoxAddTearoffs :: (IsComboBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>button-sensitivity</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #buttonSensitivity
--   </pre>
getComboBoxButtonSensitivity :: (MonadIO m, IsComboBox o) => o -> m SensitivityType

-- | Set the value of the “<tt>button-sensitivity</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #buttonSensitivity <a>:=</a> value ]
--   </pre>
setComboBoxButtonSensitivity :: (MonadIO m, IsComboBox o) => o -> SensitivityType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>button-sensitivity</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructComboBoxButtonSensitivity :: (IsComboBox o, MonadIO m) => SensitivityType -> m (GValueConstruct o)

-- | Get the value of the “<tt>cell-area</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #cellArea
--   </pre>
getComboBoxCellArea :: (MonadIO m, IsComboBox o) => o -> m (Maybe CellArea)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-area</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructComboBoxCellArea :: (IsComboBox o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>column-span-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #columnSpanColumn
--   </pre>
getComboBoxColumnSpanColumn :: (MonadIO m, IsComboBox o) => o -> m Int32

-- | Set the value of the “<tt>column-span-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #columnSpanColumn <a>:=</a> value ]
--   </pre>
setComboBoxColumnSpanColumn :: (MonadIO m, IsComboBox o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>column-span-column</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructComboBoxColumnSpanColumn :: (IsComboBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>entry-text-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #entryTextColumn
--   </pre>
getComboBoxEntryTextColumn :: (MonadIO m, IsComboBox o) => o -> m Int32

-- | Set the value of the “<tt>entry-text-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #entryTextColumn <a>:=</a> value ]
--   </pre>
setComboBoxEntryTextColumn :: (MonadIO m, IsComboBox o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>entry-text-column</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructComboBoxEntryTextColumn :: (IsComboBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-entry</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #hasEntry
--   </pre>
getComboBoxHasEntry :: (MonadIO m, IsComboBox o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-entry</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructComboBoxHasEntry :: (IsComboBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-frame</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #hasFrame
--   </pre>
getComboBoxHasFrame :: (MonadIO m, IsComboBox o) => o -> m Bool

-- | Set the value of the “<tt>has-frame</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #hasFrame <a>:=</a> value ]
--   </pre>
setComboBoxHasFrame :: (MonadIO m, IsComboBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-frame</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructComboBoxHasFrame :: (IsComboBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>id-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #idColumn
--   </pre>
getComboBoxIdColumn :: (MonadIO m, IsComboBox o) => o -> m Int32

-- | Set the value of the “<tt>id-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #idColumn <a>:=</a> value ]
--   </pre>
setComboBoxIdColumn :: (MonadIO m, IsComboBox o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>id-column</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructComboBoxIdColumn :: (IsComboBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #model
--   </pre>
getComboBoxModel :: (MonadIO m, IsComboBox o) => o -> m TreeModel

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #model <a>:=</a> value ]
--   </pre>
setComboBoxModel :: (MonadIO m, IsComboBox o, IsTreeModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructComboBoxModel :: (IsComboBox o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearComboBoxModel :: (MonadIO m, IsComboBox o) => o -> m ()

-- | Get the value of the “<tt>popup-fixed-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #popupFixedWidth
--   </pre>
getComboBoxPopupFixedWidth :: (MonadIO m, IsComboBox o) => o -> m Bool

-- | Set the value of the “<tt>popup-fixed-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #popupFixedWidth <a>:=</a> value ]
--   </pre>
setComboBoxPopupFixedWidth :: (MonadIO m, IsComboBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>popup-fixed-width</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructComboBoxPopupFixedWidth :: (IsComboBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>popup-shown</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #popupShown
--   </pre>
getComboBoxPopupShown :: (MonadIO m, IsComboBox o) => o -> m Bool

-- | Get the value of the “<tt>row-span-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #rowSpanColumn
--   </pre>
getComboBoxRowSpanColumn :: (MonadIO m, IsComboBox o) => o -> m Int32

-- | Set the value of the “<tt>row-span-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #rowSpanColumn <a>:=</a> value ]
--   </pre>
setComboBoxRowSpanColumn :: (MonadIO m, IsComboBox o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>row-span-column</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructComboBoxRowSpanColumn :: (IsComboBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>tearoff-title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #tearoffTitle
--   </pre>
getComboBoxTearoffTitle :: (MonadIO m, IsComboBox o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>tearoff-title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #tearoffTitle <a>:=</a> value ]
--   </pre>
setComboBoxTearoffTitle :: (MonadIO m, IsComboBox o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tearoff-title</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructComboBoxTearoffTitle :: (IsComboBox o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>tearoff-title</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #tearoffTitle
--   </pre>
clearComboBoxTearoffTitle :: (MonadIO m, IsComboBox o) => o -> m ()

-- | Get the value of the “<tt>wrap-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #wrapWidth
--   </pre>
getComboBoxWrapWidth :: (MonadIO m, IsComboBox o) => o -> m Int32

-- | Set the value of the “<tt>wrap-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #wrapWidth <a>:=</a> value ]
--   </pre>
setComboBoxWrapWidth :: (MonadIO m, IsComboBox o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap-width</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructComboBoxWrapWidth :: (IsComboBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new empty <a>ComboBox</a>.
--   
--   <i>Since: 2.4</i>
comboBoxNew :: (HasCallStack, MonadIO m) => m ComboBox

-- | Creates a new empty <a>ComboBox</a> using <i><tt>area</tt></i> to
--   layout cells.
comboBoxNewWithArea :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m ComboBox

-- | Creates a new empty <a>ComboBox</a> with an entry.
--   
--   The new combo box will use <i><tt>area</tt></i> to layout cells.
comboBoxNewWithAreaAndEntry :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m ComboBox

-- | Creates a new empty <a>ComboBox</a> with an entry.
--   
--   <i>Since: 2.24</i>
comboBoxNewWithEntry :: (HasCallStack, MonadIO m) => m ComboBox

-- | Creates a new <a>ComboBox</a> with the model initialized to
--   <i><tt>model</tt></i>.
--   
--   <i>Since: 2.4</i>
comboBoxNewWithModel :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m ComboBox

-- | Creates a new empty <a>ComboBox</a> with an entry and with the model
--   initialized to <i><tt>model</tt></i>.
--   
--   <i>Since: 2.24</i>
comboBoxNewWithModelAndEntry :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m ComboBox

-- | Returns the index of the currently active item, or -1 if there’s no
--   active item. If the model is a non-flat treemodel, and the active item
--   is not an immediate child of the root of the tree, this function
--   returns <tt>gtk_tree_path_get_indices (path)[0]</tt>, where
--   <tt>path</tt> is the <a>TreePath</a> of the active item.
--   
--   <i>Since: 2.4</i>
comboBoxGetActive :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Int32

-- | Returns the ID of the active row of <i><tt>comboBox</tt></i>. This
--   value is taken from the active row and the column specified by the
--   <a>ComboBox:idColumn</a> property of <i><tt>comboBox</tt></i> (see
--   <a>comboBoxSetIdColumn</a>).
--   
--   The returned value is an interned string which means that you can
--   compare the pointer by value to other interned strings and that you
--   must not free it.
--   
--   If the <a>ComboBox:idColumn</a> property of <i><tt>comboBox</tt></i>
--   is not set, or if no row is active, or if the active row has a
--   <a>Nothing</a> ID value, then <a>Nothing</a> is returned.
--   
--   <i>Since: 3.0</i>
comboBoxGetActiveId :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m (Maybe Text)

-- | Sets <i><tt>iter</tt></i> to point to the currently active item, if
--   any item is active. Otherwise, <i><tt>iter</tt></i> is left unchanged.
--   
--   <i>Since: 2.4</i>
comboBoxGetActiveIter :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m (Bool, TreeIter)

-- | Gets the current value of the :add-tearoffs property.
comboBoxGetAddTearoffs :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Bool

-- | Returns whether the combo box sets the dropdown button sensitive or
--   not when there are no items in the model.
--   
--   <i>Since: 2.14</i>
comboBoxGetButtonSensitivity :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m SensitivityType

-- | Returns the column with column span information for
--   <i><tt>comboBox</tt></i>.
--   
--   <i>Since: 2.6</i>
comboBoxGetColumnSpanColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Int32

-- | Returns the column which <i><tt>comboBox</tt></i> is using to get the
--   strings from to display in the internal entry.
--   
--   <i>Since: 2.24</i>
comboBoxGetEntryTextColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Int32

-- | Returns whether the combo box grabs focus when it is clicked with the
--   mouse. See <a>comboBoxSetFocusOnClick</a>.
--   
--   <i>Since: 2.6</i>
comboBoxGetFocusOnClick :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Bool

-- | Returns whether the combo box has an entry.
--   
--   <i>Since: 2.24</i>
comboBoxGetHasEntry :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Bool

-- | Returns the column which <i><tt>comboBox</tt></i> is using to get
--   string IDs for values from.
--   
--   <i>Since: 3.0</i>
comboBoxGetIdColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Int32

-- | Returns the <a>TreeModel</a> which is acting as data source for
--   <i><tt>comboBox</tt></i>.
--   
--   <i>Since: 2.4</i>
comboBoxGetModel :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m TreeModel

-- | Gets the accessible object corresponding to the combo box’s popup.
--   
--   This function is mostly intended for use by accessibility
--   technologies; applications should have little use for it.
--   
--   <i>Since: 2.6</i>
comboBoxGetPopupAccessible :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Object

-- | Gets whether the popup uses a fixed width matching the allocated width
--   of the combo box.
--   
--   <i>Since: 3.0</i>
comboBoxGetPopupFixedWidth :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Bool

-- | Returns the column with row span information for
--   <i><tt>comboBox</tt></i>.
--   
--   <i>Since: 2.6</i>
comboBoxGetRowSpanColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Int32

-- | Gets the current title of the menu in tearoff mode. See
--   <a>comboBoxSetAddTearoffs</a>.
--   
--   <i>Since: 2.10</i>
comboBoxGetTitle :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Text

-- | Returns the wrap width which is used to determine the number of
--   columns for the popup menu. If the wrap width is larger than 1, the
--   combo box is in table mode.
--   
--   <i>Since: 2.6</i>
comboBoxGetWrapWidth :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Int32

-- | Hides the menu or dropdown list of <i><tt>comboBox</tt></i>.
--   
--   This function is mostly intended for use by accessibility
--   technologies; applications should have little use for it.
--   
--   <i>Since: 2.4</i>
comboBoxPopdown :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m ()

-- | Pops up the menu or dropdown list of <i><tt>comboBox</tt></i>.
--   
--   This function is mostly intended for use by accessibility
--   technologies; applications should have little use for it.
--   
--   Before calling this, <i><tt>comboBox</tt></i> must be mapped, or
--   nothing will happen.
--   
--   <i>Since: 2.4</i>
comboBoxPopup :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m ()

-- | Pops up the menu or dropdown list of <i><tt>comboBox</tt></i>, the
--   popup window will be grabbed so only <i><tt>device</tt></i> and its
--   associated pointer/keyboard are the only <tt><i>GdkDevices</i></tt>
--   able to send events to it.
--   
--   <i>Since: 3.0</i>
comboBoxPopupForDevice :: (HasCallStack, MonadIO m, IsComboBox a, IsDevice b) => a -> b -> m ()

-- | Sets the active item of <i><tt>comboBox</tt></i> to be the item at
--   <i><tt>index</tt></i>.
--   
--   <i>Since: 2.4</i>
comboBoxSetActive :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Int32 -> m ()

-- | Changes the active row of <i><tt>comboBox</tt></i> to the one that has
--   an ID equal to <i><tt>activeId</tt></i>, or unsets the active row if
--   <i><tt>activeId</tt></i> is <a>Nothing</a>. Rows having a
--   <a>Nothing</a> ID string cannot be made active by this function.
--   
--   If the <a>ComboBox:idColumn</a> property of <i><tt>comboBox</tt></i>
--   is unset or if no row has the given ID then the function does nothing
--   and returns <a>False</a>.
--   
--   <i>Since: 3.0</i>
comboBoxSetActiveId :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Maybe Text -> m Bool

-- | Sets the current active item to be the one referenced by
--   <i><tt>iter</tt></i>, or unsets the active item if
--   <i><tt>iter</tt></i> is <a>Nothing</a>.
--   
--   <i>Since: 2.4</i>
comboBoxSetActiveIter :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Maybe TreeIter -> m ()

-- | Sets whether the popup menu should have a tearoff menu item.
--   
--   <i>Since: 2.6</i>
comboBoxSetAddTearoffs :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Bool -> m ()

-- | Sets whether the dropdown button of the combo box should be always
--   sensitive (<a>SensitivityTypeOn</a>), never sensitive
--   (<a>SensitivityTypeOff</a>) or only if there is at least one item to
--   display (<a>SensitivityTypeAuto</a>).
--   
--   <i>Since: 2.14</i>
comboBoxSetButtonSensitivity :: (HasCallStack, MonadIO m, IsComboBox a) => a -> SensitivityType -> m ()

-- | Sets the column with column span information for
--   <i><tt>comboBox</tt></i> to be <i><tt>columnSpan</tt></i>. The column
--   span column contains integers which indicate how many columns an item
--   should span.
--   
--   <i>Since: 2.4</i>
comboBoxSetColumnSpanColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Int32 -> m ()

-- | Sets the model column which <i><tt>comboBox</tt></i> should use to get
--   strings from to be <i><tt>textColumn</tt></i>. The column
--   <i><tt>textColumn</tt></i> in the model of <i><tt>comboBox</tt></i>
--   must be of type <tt><i>G_TYPE_STRING</i></tt>.
--   
--   This is only relevant if <i><tt>comboBox</tt></i> has been created
--   with <a>ComboBox:hasEntry</a> as <a>True</a>.
--   
--   <i>Since: 2.24</i>
comboBoxSetEntryTextColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Int32 -> m ()

-- | Sets whether the combo box will grab focus when it is clicked with the
--   mouse. Making mouse clicks not grab focus is useful in places like
--   toolbars where you don’t want the keyboard focus removed from the main
--   area of the application.
--   
--   <i>Since: 2.6</i>
comboBoxSetFocusOnClick :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Bool -> m ()

-- | Sets the model column which <i><tt>comboBox</tt></i> should use to get
--   string IDs for values from. The column <i><tt>idColumn</tt></i> in the
--   model of <i><tt>comboBox</tt></i> must be of type
--   <tt><i>G_TYPE_STRING</i></tt>.
--   
--   <i>Since: 3.0</i>
comboBoxSetIdColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Int32 -> m ()

-- | Sets the model used by <i><tt>comboBox</tt></i> to be
--   <i><tt>model</tt></i>. Will unset a previously set model (if
--   applicable). If model is <a>Nothing</a>, then it will unset the model.
--   
--   Note that this function does not clear the cell renderers, you have to
--   call <a>cellLayoutClear</a> yourself if you need to set up different
--   cell renderers for the new model.
--   
--   <i>Since: 2.4</i>
comboBoxSetModel :: (HasCallStack, MonadIO m, IsComboBox a, IsTreeModel b) => a -> Maybe b -> m ()

-- | Specifies whether the popup’s width should be a fixed width matching
--   the allocated width of the combo box.
--   
--   <i>Since: 3.0</i>
comboBoxSetPopupFixedWidth :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Bool -> m ()

-- | Sets the row separator function, which is used to determine whether a
--   row should be drawn as a separator. If the row separator function is
--   <a>Nothing</a>, no separators are drawn. This is the default value.
--   
--   <i>Since: 2.6</i>
comboBoxSetRowSeparatorFunc :: (HasCallStack, MonadIO m, IsComboBox a) => a -> TreeViewRowSeparatorFunc -> m ()

-- | Sets the column with row span information for <i><tt>comboBox</tt></i>
--   to be <i><tt>rowSpan</tt></i>. The row span column contains integers
--   which indicate how many rows an item should span.
--   
--   <i>Since: 2.4</i>
comboBoxSetRowSpanColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Int32 -> m ()

-- | Sets the menu’s title in tearoff mode.
--   
--   <i>Since: 2.10</i>
comboBoxSetTitle :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Text -> m ()

-- | Sets the wrap width of <i><tt>comboBox</tt></i> to be
--   <i><tt>width</tt></i>. The wrap width is basically the preferred
--   number of columns when you want the popup to be layed out in a table.
--   
--   <i>Since: 2.4</i>
comboBoxSetWrapWidth :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Int32 -> m ()

-- | Cast to <a>ComboBoxText</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toComboBoxText :: (MonadIO m, IsComboBoxText o) => o -> m ComboBoxText

-- | Creates a new <a>ComboBoxText</a>, which is a <a>ComboBox</a> just
--   displaying strings.
--   
--   <i>Since: 2.24</i>
comboBoxTextNew :: (HasCallStack, MonadIO m) => m ComboBoxText

-- | Creates a new <a>ComboBoxText</a>, which is a <a>ComboBox</a> just
--   displaying strings. The combo box created by this function has an
--   entry.
--   
--   <i>Since: 2.24</i>
comboBoxTextNewWithEntry :: (HasCallStack, MonadIO m) => m ComboBoxText

-- | Appends <i><tt>text</tt></i> to the list of strings stored in
--   <i><tt>comboBox</tt></i>. If <i><tt>id</tt></i> is non-<a>Nothing</a>
--   then it is used as the ID of the row.
--   
--   This is the same as calling <a>comboBoxTextInsert</a> with a position
--   of -1.
--   
--   <i>Since: 2.24</i>
comboBoxTextAppend :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Maybe Text -> Text -> m ()

-- | Appends <i><tt>text</tt></i> to the list of strings stored in
--   <i><tt>comboBox</tt></i>.
--   
--   This is the same as calling <a>comboBoxTextInsertText</a> with a
--   position of -1.
--   
--   <i>Since: 2.24</i>
comboBoxTextAppendText :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Text -> m ()

-- | Returns the currently active string in <i><tt>comboBox</tt></i>, or
--   <a>Nothing</a> if none is selected. If <i><tt>comboBox</tt></i>
--   contains an entry, this function will return its contents (which will
--   not necessarily be an item from the list).
--   
--   <i>Since: 2.24</i>
comboBoxTextGetActiveText :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> m (Maybe Text)

-- | Inserts <i><tt>text</tt></i> at <i><tt>position</tt></i> in the list
--   of strings stored in <i><tt>comboBox</tt></i>. If <i><tt>id</tt></i>
--   is non-<a>Nothing</a> then it is used as the ID of the row. See
--   <a>ComboBox:idColumn</a>.
--   
--   If <i><tt>position</tt></i> is negative then <i><tt>text</tt></i> is
--   appended.
--   
--   <i>Since: 3.0</i>
comboBoxTextInsert :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Int32 -> Maybe Text -> Text -> m ()

-- | Inserts <i><tt>text</tt></i> at <i><tt>position</tt></i> in the list
--   of strings stored in <i><tt>comboBox</tt></i>.
--   
--   If <i><tt>position</tt></i> is negative then <i><tt>text</tt></i> is
--   appended.
--   
--   This is the same as calling <a>comboBoxTextInsert</a> with a
--   <a>Nothing</a> ID string.
--   
--   <i>Since: 2.24</i>
comboBoxTextInsertText :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Int32 -> Text -> m ()

-- | Prepends <i><tt>text</tt></i> to the list of strings stored in
--   <i><tt>comboBox</tt></i>. If <i><tt>id</tt></i> is non-<a>Nothing</a>
--   then it is used as the ID of the row.
--   
--   This is the same as calling <a>comboBoxTextInsert</a> with a position
--   of 0.
--   
--   <i>Since: 2.24</i>
comboBoxTextPrepend :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Maybe Text -> Text -> m ()

-- | Prepends <i><tt>text</tt></i> to the list of strings stored in
--   <i><tt>comboBox</tt></i>.
--   
--   This is the same as calling <a>comboBoxTextInsertText</a> with a
--   position of 0.
--   
--   <i>Since: 2.24</i>
comboBoxTextPrependText :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Text -> m ()

-- | Removes the string at <i><tt>position</tt></i> from
--   <i><tt>comboBox</tt></i>.
--   
--   <i>Since: 2.24</i>
comboBoxTextRemove :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Int32 -> m ()

-- | Removes all the text entries from the combo box.
--   
--   <i>Since: 3.0</i>
comboBoxTextRemoveAll :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> m ()

-- | Cast to <a>CellView</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toCellView :: (MonadIO m, IsCellView o) => o -> m CellView

-- | Set the value of the “<tt>background</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellView [ #background <a>:=</a> value ]
--   </pre>
setCellViewBackground :: (MonadIO m, IsCellView o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellViewBackground :: (IsCellView o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>background</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #background
--   </pre>
clearCellViewBackground :: (MonadIO m, IsCellView o) => o -> m ()

-- | Get the value of the “<tt>background-gdk</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellView #backgroundGdk
--   </pre>
getCellViewBackgroundGdk :: (MonadIO m, IsCellView o) => o -> m (Maybe Color)

-- | Set the value of the “<tt>background-gdk</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellView [ #backgroundGdk <a>:=</a> value ]
--   </pre>
setCellViewBackgroundGdk :: (MonadIO m, IsCellView o) => o -> Color -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-gdk</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellViewBackgroundGdk :: (IsCellView o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Set the value of the “<tt>background-gdk</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #backgroundGdk
--   </pre>
clearCellViewBackgroundGdk :: (MonadIO m, IsCellView o) => o -> m ()

-- | Get the value of the “<tt>background-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellView #backgroundRgba
--   </pre>
getCellViewBackgroundRgba :: (MonadIO m, IsCellView o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>background-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellView [ #backgroundRgba <a>:=</a> value ]
--   </pre>
setCellViewBackgroundRgba :: (MonadIO m, IsCellView o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-rgba</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellViewBackgroundRgba :: (IsCellView o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “<tt>background-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellView #backgroundSet
--   </pre>
getCellViewBackgroundSet :: (MonadIO m, IsCellView o) => o -> m Bool

-- | Set the value of the “<tt>background-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellView [ #backgroundSet <a>:=</a> value ]
--   </pre>
setCellViewBackgroundSet :: (MonadIO m, IsCellView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellViewBackgroundSet :: (IsCellView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>cell-area</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellView #cellArea
--   </pre>
getCellViewCellArea :: (MonadIO m, IsCellView o) => o -> m (Maybe CellArea)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-area</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellViewCellArea :: (IsCellView o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>cell-area-context</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellView #cellAreaContext
--   </pre>
getCellViewCellAreaContext :: (MonadIO m, IsCellView o) => o -> m (Maybe CellAreaContext)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-area-context</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellViewCellAreaContext :: (IsCellView o, MonadIO m, IsCellAreaContext a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>draw-sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellView #drawSensitive
--   </pre>
getCellViewDrawSensitive :: (MonadIO m, IsCellView o) => o -> m Bool

-- | Set the value of the “<tt>draw-sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellView [ #drawSensitive <a>:=</a> value ]
--   </pre>
setCellViewDrawSensitive :: (MonadIO m, IsCellView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>draw-sensitive</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellViewDrawSensitive :: (IsCellView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>fit-model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellView #fitModel
--   </pre>
getCellViewFitModel :: (MonadIO m, IsCellView o) => o -> m Bool

-- | Set the value of the “<tt>fit-model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellView [ #fitModel <a>:=</a> value ]
--   </pre>
setCellViewFitModel :: (MonadIO m, IsCellView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fit-model</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellViewFitModel :: (IsCellView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellView #model
--   </pre>
getCellViewModel :: (MonadIO m, IsCellView o) => o -> m (Maybe TreeModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellView [ #model <a>:=</a> value ]
--   </pre>
setCellViewModel :: (MonadIO m, IsCellView o, IsTreeModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellViewModel :: (IsCellView o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearCellViewModel :: (MonadIO m, IsCellView o) => o -> m ()

-- | Creates a new <a>CellView</a> widget.
--   
--   <i>Since: 2.6</i>
cellViewNew :: (HasCallStack, MonadIO m) => m CellView

-- | Creates a new <a>CellView</a> widget with a specific <a>CellArea</a>
--   to layout cells and a specific <a>CellAreaContext</a>.
--   
--   Specifying the same context for a handfull of cells lets the
--   underlying area synchronize the geometry for those cells, in this way
--   alignments with cellviews for other rows are possible.
--   
--   <i>Since: 2.6</i>
cellViewNewWithContext :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b) => a -> b -> m CellView

-- | Creates a new <a>CellView</a> widget, adds a <a>CellRendererText</a>
--   to it, and makes it show <i><tt>markup</tt></i>. The text can be
--   marked up with the [Pango text markup language][PangoMarkupFormat].
--   
--   <i>Since: 2.6</i>
cellViewNewWithMarkup :: (HasCallStack, MonadIO m) => Text -> m CellView

-- | Creates a new <a>CellView</a> widget, adds a <a>CellRendererPixbuf</a>
--   to it, and makes it show <i><tt>pixbuf</tt></i>.
--   
--   <i>Since: 2.6</i>
cellViewNewWithPixbuf :: (HasCallStack, MonadIO m, IsPixbuf a) => a -> m CellView

-- | Creates a new <a>CellView</a> widget, adds a <a>CellRendererText</a>
--   to it, and makes it show <i><tt>text</tt></i>.
--   
--   <i>Since: 2.6</i>
cellViewNewWithText :: (HasCallStack, MonadIO m) => Text -> m CellView

-- | Returns a <a>TreePath</a> referring to the currently displayed row. If
--   no row is currently displayed, <a>Nothing</a> is returned.
--   
--   <i>Since: 2.6</i>
cellViewGetDisplayedRow :: (HasCallStack, MonadIO m, IsCellView a) => a -> m (Maybe TreePath)

-- | Gets whether <i><tt>cellView</tt></i> is configured to draw all of its
--   cells in a sensitive state.
--   
--   <i>Since: 3.0</i>
cellViewGetDrawSensitive :: (HasCallStack, MonadIO m, IsCellView a) => a -> m Bool

-- | Gets whether <i><tt>cellView</tt></i> is configured to request space
--   to fit the entire <a>TreeModel</a>.
--   
--   <i>Since: 3.0</i>
cellViewGetFitModel :: (HasCallStack, MonadIO m, IsCellView a) => a -> m Bool

-- | Returns the model for <i><tt>cellView</tt></i>. If no model is used
--   <a>Nothing</a> is returned.
--   
--   <i>Since: 2.16</i>
cellViewGetModel :: (HasCallStack, MonadIO m, IsCellView a) => a -> m (Maybe TreeModel)

-- | Sets <i><tt>requisition</tt></i> to the size needed by
--   <i><tt>cellView</tt></i> to display the model row pointed to by
--   <i><tt>path</tt></i>.
--   
--   <i>Since: 2.6</i>
cellViewGetSizeOfRow :: (HasCallStack, MonadIO m, IsCellView a) => a -> TreePath -> m (Bool, Requisition)

-- | Sets the background color of <i><tt>view</tt></i>.
--   
--   <i>Since: 2.6</i>
cellViewSetBackgroundColor :: (HasCallStack, MonadIO m, IsCellView a) => a -> Color -> m ()

-- | Sets the background color of <i><tt>cellView</tt></i>.
--   
--   <i>Since: 3.0</i>
cellViewSetBackgroundRgba :: (HasCallStack, MonadIO m, IsCellView a) => a -> RGBA -> m ()

-- | Sets the row of the model that is currently displayed by the
--   <a>CellView</a>. If the path is unset, then the contents of the
--   cellview “stick” at their last value; this is not normally a desired
--   result, but may be a needed intermediate state if say, the model for
--   the <a>CellView</a> becomes temporarily empty.
--   
--   <i>Since: 2.6</i>
cellViewSetDisplayedRow :: (HasCallStack, MonadIO m, IsCellView a) => a -> Maybe TreePath -> m ()

-- | Sets whether <i><tt>cellView</tt></i> should draw all of its cells in
--   a sensitive state, this is used by <a>ComboBox</a> menus to ensure
--   that rows with insensitive cells that contain children appear
--   sensitive in the parent menu item.
--   
--   <i>Since: 3.0</i>
cellViewSetDrawSensitive :: (HasCallStack, MonadIO m, IsCellView a) => a -> Bool -> m ()

-- | Sets whether <i><tt>cellView</tt></i> should request space to fit the
--   entire <a>TreeModel</a>.
--   
--   This is used by <a>ComboBox</a> to ensure that the cell view displayed
--   on the combo box’s button always gets enough space and does not resize
--   when selection changes.
--   
--   <i>Since: 3.0</i>
cellViewSetFitModel :: (HasCallStack, MonadIO m, IsCellView a) => a -> Bool -> m ()

-- | Sets the model for <i><tt>cellView</tt></i>. If
--   <i><tt>cellView</tt></i> already has a model set, it will remove it
--   before setting the new model. If <i><tt>model</tt></i> is
--   <a>Nothing</a>, then it will unset the old model.
--   
--   <i>Since: 2.6</i>
cellViewSetModel :: (HasCallStack, MonadIO m, IsCellView a, IsTreeModel b) => a -> Maybe b -> m ()

-- | Cast to <a>CellAreaBox</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCellAreaBox :: (MonadIO m, IsCellAreaBox o) => o -> m CellAreaBox

-- | Get the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellAreaBox #spacing
--   </pre>
getCellAreaBoxSpacing :: (MonadIO m, IsCellAreaBox o) => o -> m Int32

-- | Set the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellAreaBox [ #spacing <a>:=</a> value ]
--   </pre>
setCellAreaBoxSpacing :: (MonadIO m, IsCellAreaBox o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>spacing</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellAreaBoxSpacing :: (IsCellAreaBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Creates a new <a>CellAreaBox</a>.
--   
--   <i>Since: 3.0</i>
cellAreaBoxNew :: (HasCallStack, MonadIO m) => m CellAreaBox

-- | Gets the spacing added between cell renderers.
--   
--   <i>Since: 3.0</i>
cellAreaBoxGetSpacing :: (HasCallStack, MonadIO m, IsCellAreaBox a) => a -> m Int32

-- | Adds <i><tt>renderer</tt></i> to <i><tt>box</tt></i>, packed with
--   reference to the end of <i><tt>box</tt></i>.
--   
--   The <i><tt>renderer</tt></i> is packed after (away from end of) any
--   other <a>CellRenderer</a> packed with reference to the end of
--   <i><tt>box</tt></i>.
--   
--   <i>Since: 3.0</i>
cellAreaBoxPackEnd :: (HasCallStack, MonadIO m, IsCellAreaBox a, IsCellRenderer b) => a -> b -> Bool -> Bool -> Bool -> m ()

-- | Adds <i><tt>renderer</tt></i> to <i><tt>box</tt></i>, packed with
--   reference to the start of <i><tt>box</tt></i>.
--   
--   The <i><tt>renderer</tt></i> is packed after any other
--   <a>CellRenderer</a> packed with reference to the start of
--   <i><tt>box</tt></i>.
--   
--   <i>Since: 3.0</i>
cellAreaBoxPackStart :: (HasCallStack, MonadIO m, IsCellAreaBox a, IsCellRenderer b) => a -> b -> Bool -> Bool -> Bool -> m ()

-- | Sets the spacing to add between cell renderers in <i><tt>box</tt></i>.
--   
--   <i>Since: 3.0</i>
cellAreaBoxSetSpacing :: (HasCallStack, MonadIO m, IsCellAreaBox a) => a -> Int32 -> m ()

-- | <i>No description available in the introspection data.</i>
cellAccessibleParentActivate :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m ()

-- | <i>No description available in the introspection data.</i>
cellAccessibleParentEdit :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m ()

-- | <i>No description available in the introspection data.</i>
cellAccessibleParentExpandCollapse :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m ()

-- | <i>No description available in the introspection data.</i>
cellAccessibleParentGetCellArea :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m Rectangle

-- | <i>No description available in the introspection data.</i>
cellAccessibleParentGetCellExtents :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> CoordType -> m (Int32, Int32, Int32, Int32)

-- | <i>No description available in the introspection data.</i>
cellAccessibleParentGetCellPosition :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m (Int32, Int32)

-- | <i>No description available in the introspection data.</i>
cellAccessibleParentGetChildIndex :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m Int32

-- | <i>No description available in the introspection data.</i>
cellAccessibleParentGetColumnHeaderCells :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m [Object]

-- | <i>No description available in the introspection data.</i>
cellAccessibleParentGetRendererState :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m [CellRendererState]

-- | <i>No description available in the introspection data.</i>
cellAccessibleParentGetRowHeaderCells :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m [Object]

-- | <i>No description available in the introspection data.</i>
cellAccessibleParentGrabFocus :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b) => a -> b -> m Bool

-- | <i>No description available in the introspection data.</i>
cellAccessibleParentUpdateRelationset :: (HasCallStack, MonadIO m, IsCellAccessibleParent a, IsCellAccessible b, IsRelationSet c) => a -> b -> c -> m ()

-- | Cast to <a>TreeViewAccessible</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toTreeViewAccessible :: (MonadIO m, IsTreeViewAccessible o) => o -> m TreeViewAccessible

-- | Cast to <a>AppChooser</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAppChooser :: (MonadIO m, IsAppChooser o) => o -> m AppChooser

-- | Get the value of the “<tt>content-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooser #contentType
--   </pre>
getAppChooserContentType :: (MonadIO m, IsAppChooser o) => o -> m (Maybe Text)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>content-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAppChooserContentType :: (IsAppChooser o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Returns the currently selected application.
--   
--   <i>Since: 3.0</i>
appChooserGetAppInfo :: (HasCallStack, MonadIO m, IsAppChooser a) => a -> m (Maybe AppInfo)

-- | Returns the current value of the
--   <a>AppChooser</a>:<tt><i>content-type</i></tt> property.
--   
--   <i>Since: 3.0</i>
appChooserGetContentType :: (HasCallStack, MonadIO m, IsAppChooser a) => a -> m Text

-- | Cast to <a>AppChooserDialog</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toAppChooserDialog :: (MonadIO m, IsAppChooserDialog o) => o -> m AppChooserDialog

-- | Get the value of the “<tt>gfile</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserDialog #gfile
--   </pre>
getAppChooserDialogGfile :: (MonadIO m, IsAppChooserDialog o) => o -> m (Maybe File)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gfile</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAppChooserDialogGfile :: (IsAppChooserDialog o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>heading</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserDialog #heading
--   </pre>
getAppChooserDialogHeading :: (MonadIO m, IsAppChooserDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>heading</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserDialog [ #heading <a>:=</a> value ]
--   </pre>
setAppChooserDialogHeading :: (MonadIO m, IsAppChooserDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>heading</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAppChooserDialogHeading :: (IsAppChooserDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Creates a new <a>AppChooserDialog</a> for the provided <a>File</a>, to
--   allow the user to select an application for it.
--   
--   <i>Since: 3.0</i>
appChooserDialogNew :: (HasCallStack, MonadIO m, IsWindow a, IsFile b) => Maybe a -> [DialogFlags] -> b -> m AppChooserDialog

-- | Creates a new <a>AppChooserDialog</a> for the provided content type,
--   to allow the user to select an application for it.
--   
--   <i>Since: 3.0</i>
appChooserDialogNewForContentType :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> [DialogFlags] -> Text -> m AppChooserDialog

-- | Returns the text to display at the top of the dialog.
appChooserDialogGetHeading :: (HasCallStack, MonadIO m, IsAppChooserDialog a) => a -> m (Maybe Text)

-- | Returns the <a>AppChooserWidget</a> of this dialog.
--   
--   <i>Since: 3.0</i>
appChooserDialogGetWidget :: (HasCallStack, MonadIO m, IsAppChooserDialog a) => a -> m Widget

-- | Sets the text to display at the top of the dialog. If the heading is
--   not set, the dialog displays a default text.
appChooserDialogSetHeading :: (HasCallStack, MonadIO m, IsAppChooserDialog a) => a -> Text -> m ()

-- | Cast to <a>AppChooserButton</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toAppChooserButton :: (MonadIO m, IsAppChooserButton o) => o -> m AppChooserButton

-- | Connect a signal handler for the <a>customItemActivated</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> appChooserButton #customItemActivated callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to
--   “<tt>custom-item-activated::detail</tt>” instead.
onAppChooserButtonCustomItemActivated :: (IsAppChooserButton a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AppChooserButtonCustomItemActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>customItemActivated</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> appChooserButton #customItemActivated callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to
--   “<tt>custom-item-activated::detail</tt>” instead.
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAppChooserButtonCustomItemActivated :: (IsAppChooserButton a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AppChooserButtonCustomItemActivatedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>heading</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserButton #heading
--   </pre>
getAppChooserButtonHeading :: (MonadIO m, IsAppChooserButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>heading</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserButton [ #heading <a>:=</a> value ]
--   </pre>
setAppChooserButtonHeading :: (MonadIO m, IsAppChooserButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>heading</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAppChooserButtonHeading :: (IsAppChooserButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-default-item</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserButton #showDefaultItem
--   </pre>
getAppChooserButtonShowDefaultItem :: (MonadIO m, IsAppChooserButton o) => o -> m Bool

-- | Set the value of the “<tt>show-default-item</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserButton [ #showDefaultItem <a>:=</a> value ]
--   </pre>
setAppChooserButtonShowDefaultItem :: (MonadIO m, IsAppChooserButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-default-item</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAppChooserButtonShowDefaultItem :: (IsAppChooserButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-dialog-item</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserButton #showDialogItem
--   </pre>
getAppChooserButtonShowDialogItem :: (MonadIO m, IsAppChooserButton o) => o -> m Bool

-- | Set the value of the “<tt>show-dialog-item</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserButton [ #showDialogItem <a>:=</a> value ]
--   </pre>
setAppChooserButtonShowDialogItem :: (MonadIO m, IsAppChooserButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-dialog-item</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAppChooserButtonShowDialogItem :: (IsAppChooserButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>AppChooserButton</a> for applications that can handle
--   content of the given type.
--   
--   <i>Since: 3.0</i>
appChooserButtonNew :: (HasCallStack, MonadIO m) => Text -> m AppChooserButton

-- | Appends a custom item to the list of applications that is shown in the
--   popup; the item name must be unique per-widget. Clients can use the
--   provided name as a detail for the
--   <a>AppChooserButton::customItemActivated</a> signal, to add a callback
--   for the activation of a particular custom item in the list. See also
--   <a>appChooserButtonAppendSeparator</a>.
--   
--   <i>Since: 3.0</i>
appChooserButtonAppendCustomItem :: (HasCallStack, MonadIO m, IsAppChooserButton a, IsIcon b) => a -> Text -> Text -> b -> m ()

-- | Appends a separator to the list of applications that is shown in the
--   popup.
--   
--   <i>Since: 3.0</i>
appChooserButtonAppendSeparator :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> m ()

-- | Returns the text to display at the top of the dialog.
appChooserButtonGetHeading :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> m (Maybe Text)

-- | Returns the current value of the
--   <a>AppChooserButton:showDefaultItem</a> property.
--   
--   <i>Since: 3.2</i>
appChooserButtonGetShowDefaultItem :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> m Bool

-- | Returns the current value of the
--   <a>AppChooserButton:showDialogItem</a> property.
--   
--   <i>Since: 3.0</i>
appChooserButtonGetShowDialogItem :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> m Bool

-- | Selects a custom item previously added with
--   <a>appChooserButtonAppendCustomItem</a>.
--   
--   Use <a>appChooserRefresh</a> to bring the selection to its initial
--   state.
--   
--   <i>Since: 3.0</i>
appChooserButtonSetActiveCustomItem :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> Text -> m ()

-- | Sets the text to display at the top of the dialog. If the heading is
--   not set, the dialog displays a default text.
appChooserButtonSetHeading :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> Text -> m ()

-- | Sets whether the dropdown menu of this button should show the default
--   application for the given content type at top.
--   
--   <i>Since: 3.2</i>
appChooserButtonSetShowDefaultItem :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> Bool -> m ()

-- | Sets whether the dropdown menu of this button should show an entry to
--   trigger a <a>AppChooserDialog</a>.
--   
--   <i>Since: 3.0</i>
appChooserButtonSetShowDialogItem :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> Bool -> m ()

-- | Cast to <a>ToolItem</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toToolItem :: (MonadIO m, IsToolItem o) => o -> m ToolItem

-- | Connect a signal handler for the <a>createMenuProxy</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> toolItem #createMenuProxy callback
--   </pre>
onToolItemCreateMenuProxy :: (IsToolItem a, MonadIO m) => a -> ((?self :: a) => ToolItemCreateMenuProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>createMenuProxy</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> toolItem #createMenuProxy callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterToolItemCreateMenuProxy :: (IsToolItem a, MonadIO m) => a -> ((?self :: a) => ToolItemCreateMenuProxyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toolbarReconfigured</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> toolItem #toolbarReconfigured callback
--   </pre>
onToolItemToolbarReconfigured :: (IsToolItem a, MonadIO m) => a -> ((?self :: a) => ToolItemToolbarReconfiguredCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toolbarReconfigured</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> toolItem #toolbarReconfigured callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterToolItemToolbarReconfigured :: (IsToolItem a, MonadIO m) => a -> ((?self :: a) => ToolItemToolbarReconfiguredCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>is-important</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolItem #isImportant
--   </pre>
getToolItemIsImportant :: (MonadIO m, IsToolItem o) => o -> m Bool

-- | Set the value of the “<tt>is-important</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolItem [ #isImportant <a>:=</a> value ]
--   </pre>
setToolItemIsImportant :: (MonadIO m, IsToolItem o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>is-important</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructToolItemIsImportant :: (IsToolItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible-horizontal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolItem #visibleHorizontal
--   </pre>
getToolItemVisibleHorizontal :: (MonadIO m, IsToolItem o) => o -> m Bool

-- | Set the value of the “<tt>visible-horizontal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolItem [ #visibleHorizontal <a>:=</a> value ]
--   </pre>
setToolItemVisibleHorizontal :: (MonadIO m, IsToolItem o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible-horizontal</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructToolItemVisibleHorizontal :: (IsToolItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible-vertical</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolItem #visibleVertical
--   </pre>
getToolItemVisibleVertical :: (MonadIO m, IsToolItem o) => o -> m Bool

-- | Set the value of the “<tt>visible-vertical</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolItem [ #visibleVertical <a>:=</a> value ]
--   </pre>
setToolItemVisibleVertical :: (MonadIO m, IsToolItem o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible-vertical</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructToolItemVisibleVertical :: (IsToolItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>ToolItem</a>
--   
--   <i>Since: 2.4</i>
toolItemNew :: (HasCallStack, MonadIO m) => m ToolItem

-- | Returns whether <i><tt>toolItem</tt></i> is allocated extra space. See
--   <a>toolItemSetExpand</a>.
--   
--   <i>Since: 2.4</i>
toolItemGetExpand :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Bool

-- | Returns whether <i><tt>toolItem</tt></i> is the same size as other
--   homogeneous items. See <a>toolItemSetHomogeneous</a>.
--   
--   <i>Since: 2.4</i>
toolItemGetHomogeneous :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Bool

-- | Returns whether <i><tt>toolItem</tt></i> is considered important. See
--   <a>toolItemSetIsImportant</a>
--   
--   <i>Since: 2.4</i>
toolItemGetIsImportant :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Bool

-- | If <i><tt>menuItemId</tt></i> matches the string passed to
--   <a>toolItemSetProxyMenuItem</a> return the corresponding
--   <a>MenuItem</a>.
--   
--   Custom subclasses of <a>ToolItem</a> should use this function to
--   update their menu item when the <a>ToolItem</a> changes. That the
--   <i><tt>menuItemIds</tt></i> must match ensures that a <a>ToolItem</a>
--   will not inadvertently change a menu item that they did not create.
--   
--   <i>Since: 2.4</i>
toolItemGetProxyMenuItem :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Text -> m (Maybe Widget)

-- | Returns whether <i><tt>toolItem</tt></i> has a drag window. See
--   <a>toolItemSetUseDragWindow</a>.
--   
--   <i>Since: 2.4</i>
toolItemGetUseDragWindow :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Bool

-- | Returns whether the <i><tt>toolItem</tt></i> is visible on toolbars
--   that are docked horizontally.
--   
--   <i>Since: 2.4</i>
toolItemGetVisibleHorizontal :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Bool

-- | Returns whether <i><tt>toolItem</tt></i> is visible when the toolbar
--   is docked vertically. See <a>toolItemSetVisibleVertical</a>.
--   
--   <i>Since: 2.4</i>
toolItemGetVisibleVertical :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Bool

-- | Returns the <a>MenuItem</a> that was last set by
--   <a>toolItemSetProxyMenuItem</a>, ie. the <a>MenuItem</a> that is going
--   to appear in the overflow menu.
--   
--   <i>Since: 2.4</i>
toolItemRetrieveProxyMenuItem :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m Widget

-- | Sets whether <i><tt>toolItem</tt></i> is to be allocated the same size
--   as other homogeneous items. The effect is that all homogeneous items
--   will have the same width as the widest of the items.
--   
--   <i>Since: 2.4</i>
toolItemSetHomogeneous :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Bool -> m ()

-- | Sets whether <i><tt>toolItem</tt></i> should be considered important.
--   The <a>ToolButton</a> class uses this property to determine whether to
--   show or hide its label when the toolbar style is
--   <a>ToolbarStyleBothHoriz</a>. The result is that only tool buttons
--   with the “is_important” property set have labels, an effect known as
--   “priority text”
--   
--   <i>Since: 2.4</i>
toolItemSetIsImportant :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Bool -> m ()

-- | Sets the markup text to be displayed as tooltip on the item. See
--   <a>widgetSetTooltipMarkup</a>.
--   
--   <i>Since: 2.12</i>
toolItemSetTooltipMarkup :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Text -> m ()

-- | Sets whether <i><tt>toolItem</tt></i> has a drag window. When
--   <a>True</a> the toolitem can be used as a drag source through
--   <a>widgetDragSourceSet</a>. When <i><tt>toolItem</tt></i> has a drag
--   window it will intercept all events, even those that would otherwise
--   be sent to a child of <i><tt>toolItem</tt></i>.
--   
--   <i>Since: 2.4</i>
toolItemSetUseDragWindow :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Bool -> m ()

-- | Sets whether <i><tt>toolItem</tt></i> is visible when the toolbar is
--   docked horizontally.
--   
--   <i>Since: 2.4</i>
toolItemSetVisibleHorizontal :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Bool -> m ()

-- | Sets whether <i><tt>toolItem</tt></i> is visible when the toolbar is
--   docked vertically. Some tool items, such as text entries, are too wide
--   to be useful on a vertically docked toolbar. If
--   <i><tt>visibleVertical</tt></i> is <a>False</a>
--   <i><tt>toolItem</tt></i> will not appear on toolbars that are docked
--   vertically.
--   
--   <i>Since: 2.4</i>
toolItemSetVisibleVertical :: (HasCallStack, MonadIO m, IsToolItem a) => a -> Bool -> m ()

-- | Emits the signal <a>ToolItem</a>::<tt><i>toolbar_reconfigured</i></tt>
--   on <i><tt>toolItem</tt></i>. <a>Toolbar</a> and other <a>ToolShell</a>
--   implementations use this function to notify children, when some aspect
--   of their configuration changes.
--   
--   <i>Since: 2.14</i>
toolItemToolbarReconfigured :: (HasCallStack, MonadIO m, IsToolItem a) => a -> m ()

-- | Cast to <a>Toolbar</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toToolbar :: (MonadIO m, IsToolbar o) => o -> m Toolbar

-- | Connect a signal handler for the <a>focusHomeOrEnd</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> toolbar #focusHomeOrEnd callback
--   </pre>
onToolbarFocusHomeOrEnd :: (IsToolbar a, MonadIO m) => a -> ((?self :: a) => ToolbarFocusHomeOrEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>focusHomeOrEnd</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> toolbar #focusHomeOrEnd callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterToolbarFocusHomeOrEnd :: (IsToolbar a, MonadIO m) => a -> ((?self :: a) => ToolbarFocusHomeOrEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>orientationChanged</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> toolbar #orientationChanged callback
--   </pre>
onToolbarOrientationChanged :: (IsToolbar a, MonadIO m) => a -> ((?self :: a) => ToolbarOrientationChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>orientationChanged</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> toolbar #orientationChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterToolbarOrientationChanged :: (IsToolbar a, MonadIO m) => a -> ((?self :: a) => ToolbarOrientationChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popupContextMenu</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> toolbar #popupContextMenu callback
--   </pre>
onToolbarPopupContextMenu :: (IsToolbar a, MonadIO m) => a -> ((?self :: a) => ToolbarPopupContextMenuCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popupContextMenu</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> toolbar #popupContextMenu callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterToolbarPopupContextMenu :: (IsToolbar a, MonadIO m) => a -> ((?self :: a) => ToolbarPopupContextMenuCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>styleChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> toolbar #styleChanged callback
--   </pre>
onToolbarStyleChanged :: (IsToolbar a, MonadIO m) => a -> ((?self :: a) => ToolbarStyleChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>styleChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> toolbar #styleChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterToolbarStyleChanged :: (IsToolbar a, MonadIO m) => a -> ((?self :: a) => ToolbarStyleChangedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>icon-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolbar #iconSize
--   </pre>
getToolbarIconSize :: (MonadIO m, IsToolbar o) => o -> m IconSize

-- | Set the value of the “<tt>icon-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolbar [ #iconSize <a>:=</a> value ]
--   </pre>
setToolbarIconSize :: (MonadIO m, IsToolbar o) => o -> IconSize -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-size</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructToolbarIconSize :: (IsToolbar o, MonadIO m) => IconSize -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon-size-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolbar #iconSizeSet
--   </pre>
getToolbarIconSizeSet :: (MonadIO m, IsToolbar o) => o -> m Bool

-- | Set the value of the “<tt>icon-size-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolbar [ #iconSizeSet <a>:=</a> value ]
--   </pre>
setToolbarIconSizeSet :: (MonadIO m, IsToolbar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-size-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructToolbarIconSizeSet :: (IsToolbar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-arrow</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolbar #showArrow
--   </pre>
getToolbarShowArrow :: (MonadIO m, IsToolbar o) => o -> m Bool

-- | Set the value of the “<tt>show-arrow</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolbar [ #showArrow <a>:=</a> value ]
--   </pre>
setToolbarShowArrow :: (MonadIO m, IsToolbar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-arrow</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructToolbarShowArrow :: (IsToolbar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>toolbar-style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolbar #toolbarStyle
--   </pre>
getToolbarToolbarStyle :: (MonadIO m, IsToolbar o) => o -> m ToolbarStyle

-- | Set the value of the “<tt>toolbar-style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolbar [ #toolbarStyle <a>:=</a> value ]
--   </pre>
setToolbarToolbarStyle :: (MonadIO m, IsToolbar o) => o -> ToolbarStyle -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>toolbar-style</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructToolbarToolbarStyle :: (IsToolbar o, MonadIO m) => ToolbarStyle -> m (GValueConstruct o)

-- | Creates a new toolbar.
toolbarNew :: (HasCallStack, MonadIO m) => m Toolbar

-- | Returns the position corresponding to the indicated point on
--   <i><tt>toolbar</tt></i>. This is useful when dragging items to the
--   toolbar: this function returns the position a new item should be
--   inserted.
--   
--   <i><tt>x</tt></i> and <i><tt>y</tt></i> are in <i><tt>toolbar</tt></i>
--   coordinates.
--   
--   <i>Since: 2.4</i>
toolbarGetDropIndex :: (HasCallStack, MonadIO m, IsToolbar a) => a -> Int32 -> Int32 -> m Int32

-- | Retrieves the icon size for the toolbar. See
--   <a>toolbarSetIconSize</a>.
toolbarGetIconSize :: (HasCallStack, MonadIO m, IsToolbar a) => a -> m IconSize

-- | Returns the position of <i><tt>item</tt></i> on the toolbar, starting
--   from 0. It is an error if <i><tt>item</tt></i> is not a child of the
--   toolbar.
--   
--   <i>Since: 2.4</i>
toolbarGetItemIndex :: (HasCallStack, MonadIO m, IsToolbar a, IsToolItem b) => a -> b -> m Int32

-- | Returns the number of items on the toolbar.
--   
--   <i>Since: 2.4</i>
toolbarGetNItems :: (HasCallStack, MonadIO m, IsToolbar a) => a -> m Int32

-- | Returns the <i><tt>n</tt></i>'th item on <i><tt>toolbar</tt></i>, or
--   <a>Nothing</a> if the toolbar does not contain an <i><tt>n</tt></i>'th
--   item.
--   
--   <i>Since: 2.4</i>
toolbarGetNthItem :: (HasCallStack, MonadIO m, IsToolbar a) => a -> Int32 -> m (Maybe ToolItem)

-- | Returns the relief style of buttons on <i><tt>toolbar</tt></i>. See
--   <a>buttonSetRelief</a>.
--   
--   <i>Since: 2.4</i>
toolbarGetReliefStyle :: (HasCallStack, MonadIO m, IsToolbar a) => a -> m ReliefStyle

-- | Returns whether the toolbar has an overflow menu. See
--   <a>toolbarSetShowArrow</a>.
--   
--   <i>Since: 2.4</i>
toolbarGetShowArrow :: (HasCallStack, MonadIO m, IsToolbar a) => a -> m Bool

-- | Retrieves whether the toolbar has text, icons, or both . See
--   <a>toolbarSetStyle</a>.
toolbarGetStyle :: (HasCallStack, MonadIO m, IsToolbar a) => a -> m ToolbarStyle

-- | Insert a <a>ToolItem</a> into the toolbar at position
--   <i><tt>pos</tt></i>. If <i><tt>pos</tt></i> is 0 the item is prepended
--   to the start of the toolbar. If <i><tt>pos</tt></i> is negative, the
--   item is appended to the end of the toolbar.
--   
--   <i>Since: 2.4</i>
toolbarInsert :: (HasCallStack, MonadIO m, IsToolbar a, IsToolItem b) => a -> b -> Int32 -> m ()

-- | Highlights <i><tt>toolbar</tt></i> to give an idea of what it would
--   look like if <i><tt>item</tt></i> was added to <i><tt>toolbar</tt></i>
--   at the position indicated by <i><tt>index_</tt></i>. If
--   <i><tt>item</tt></i> is <a>Nothing</a>, highlighting is turned off. In
--   that case <i><tt>index_</tt></i> is ignored.
--   
--   The <i><tt>toolItem</tt></i> passed to this function must not be part
--   of any widget hierarchy. When an item is set as drop highlight item it
--   can not added to any widget hierarchy or used as highlight item for
--   another toolbar.
--   
--   <i>Since: 2.4</i>
toolbarSetDropHighlightItem :: (HasCallStack, MonadIO m, IsToolbar a, IsToolItem b) => a -> Maybe b -> Int32 -> m ()

-- | This function sets the size of stock icons in the toolbar. You can
--   call it both before you add the icons and after they’ve been added.
--   The size you set will override user preferences for the default icon
--   size.
--   
--   This should only be used for special-purpose toolbars, normal
--   application toolbars should respect the user preferences for the size
--   of icons.
toolbarSetIconSize :: (HasCallStack, MonadIO m, IsToolbar a) => a -> IconSize -> m ()

-- | Sets whether to show an overflow menu when <i><tt>toolbar</tt></i>
--   isn’t allocated enough size to show all of its items. If <a>True</a>,
--   items which can’t fit in <i><tt>toolbar</tt></i>, and which have a
--   proxy menu item set by <a>toolItemSetProxyMenuItem</a> or
--   <a>ToolItem::createMenuProxy</a>, will be available in an overflow
--   menu, which can be opened by an added arrow button. If <a>False</a>,
--   <i><tt>toolbar</tt></i> will request enough size to fit all of its
--   child items without any overflow.
--   
--   <i>Since: 2.4</i>
toolbarSetShowArrow :: (HasCallStack, MonadIO m, IsToolbar a) => a -> Bool -> m ()

-- | Alters the view of <i><tt>toolbar</tt></i> to display either icons
--   only, text only, or both.
toolbarSetStyle :: (HasCallStack, MonadIO m, IsToolbar a) => a -> ToolbarStyle -> m ()

-- | Unsets toolbar icon size set with <a>toolbarSetIconSize</a>, so that
--   user preferences will be used to determine the icon size.
toolbarUnsetIconSize :: (HasCallStack, MonadIO m, IsToolbar a) => a -> m ()

-- | Unsets a toolbar style set with <a>toolbarSetStyle</a>, so that user
--   preferences will be used to determine the toolbar style.
toolbarUnsetStyle :: (HasCallStack, MonadIO m, IsToolbar a) => a -> m ()

-- | Cast to <a>ToolItemGroup</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toToolItemGroup :: (MonadIO m, IsToolItemGroup o) => o -> m ToolItemGroup

-- | Get the value of the “<tt>collapsed</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolItemGroup #collapsed
--   </pre>
getToolItemGroupCollapsed :: (MonadIO m, IsToolItemGroup o) => o -> m Bool

-- | Set the value of the “<tt>collapsed</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolItemGroup [ #collapsed <a>:=</a> value ]
--   </pre>
setToolItemGroupCollapsed :: (MonadIO m, IsToolItemGroup o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>collapsed</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructToolItemGroupCollapsed :: (IsToolItemGroup o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>ellipsize</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolItemGroup #ellipsize
--   </pre>
getToolItemGroupEllipsize :: (MonadIO m, IsToolItemGroup o) => o -> m EllipsizeMode

-- | Set the value of the “<tt>ellipsize</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolItemGroup [ #ellipsize <a>:=</a> value ]
--   </pre>
setToolItemGroupEllipsize :: (MonadIO m, IsToolItemGroup o) => o -> EllipsizeMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ellipsize</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructToolItemGroupEllipsize :: (IsToolItemGroup o, MonadIO m) => EllipsizeMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>header-relief</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolItemGroup #headerRelief
--   </pre>
getToolItemGroupHeaderRelief :: (MonadIO m, IsToolItemGroup o) => o -> m ReliefStyle

-- | Set the value of the “<tt>header-relief</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolItemGroup [ #headerRelief <a>:=</a> value ]
--   </pre>
setToolItemGroupHeaderRelief :: (MonadIO m, IsToolItemGroup o) => o -> ReliefStyle -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>header-relief</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructToolItemGroupHeaderRelief :: (IsToolItemGroup o, MonadIO m) => ReliefStyle -> m (GValueConstruct o)

-- | Get the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolItemGroup #label
--   </pre>
getToolItemGroupLabel :: (MonadIO m, IsToolItemGroup o) => o -> m Text

-- | Set the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolItemGroup [ #label <a>:=</a> value ]
--   </pre>
setToolItemGroupLabel :: (MonadIO m, IsToolItemGroup o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructToolItemGroupLabel :: (IsToolItemGroup o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>label-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolItemGroup #labelWidget
--   </pre>
getToolItemGroupLabelWidget :: (MonadIO m, IsToolItemGroup o) => o -> m Widget

-- | Set the value of the “<tt>label-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolItemGroup [ #labelWidget <a>:=</a> value ]
--   </pre>
setToolItemGroupLabelWidget :: (MonadIO m, IsToolItemGroup o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label-widget</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructToolItemGroupLabelWidget :: (IsToolItemGroup o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Creates a new tool item group with label <i><tt>label</tt></i>.
--   
--   <i>Since: 2.20</i>
toolItemGroupNew :: (HasCallStack, MonadIO m) => Text -> m ToolItemGroup

-- | Gets whether <i><tt>group</tt></i> is collapsed or expanded.
--   
--   <i>Since: 2.20</i>
toolItemGroupGetCollapsed :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> m Bool

-- | Gets the tool item at position (x, y).
--   
--   <i>Since: 2.20</i>
toolItemGroupGetDropItem :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> Int32 -> Int32 -> m ToolItem

-- | Gets the ellipsization mode of <i><tt>group</tt></i>.
--   
--   <i>Since: 2.20</i>
toolItemGroupGetEllipsize :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> m EllipsizeMode

-- | Gets the relief mode of the header button of <i><tt>group</tt></i>.
--   
--   <i>Since: 2.20</i>
toolItemGroupGetHeaderRelief :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> m ReliefStyle

-- | Gets the position of <i><tt>item</tt></i> in <i><tt>group</tt></i> as
--   index.
--   
--   <i>Since: 2.20</i>
toolItemGroupGetItemPosition :: (HasCallStack, MonadIO m, IsToolItemGroup a, IsToolItem b) => a -> b -> m Int32

-- | Gets the label of <i><tt>group</tt></i>.
--   
--   <i>Since: 2.20</i>
toolItemGroupGetLabel :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> m Text

-- | Gets the label widget of <i><tt>group</tt></i>. See
--   <a>toolItemGroupSetLabelWidget</a>.
--   
--   <i>Since: 2.20</i>
toolItemGroupGetLabelWidget :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> m Widget

-- | Gets the number of tool items in <i><tt>group</tt></i>.
--   
--   <i>Since: 2.20</i>
toolItemGroupGetNItems :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> m Word32

-- | Gets the tool item at <i><tt>index</tt></i> in group.
--   
--   <i>Since: 2.20</i>
toolItemGroupGetNthItem :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> Word32 -> m ToolItem

-- | Inserts <i><tt>item</tt></i> at <i><tt>position</tt></i> in the list
--   of children of <i><tt>group</tt></i>.
--   
--   <i>Since: 2.20</i>
toolItemGroupInsert :: (HasCallStack, MonadIO m, IsToolItemGroup a, IsToolItem b) => a -> b -> Int32 -> m ()

-- | Sets whether the <i><tt>group</tt></i> should be collapsed or
--   expanded.
--   
--   <i>Since: 2.20</i>
toolItemGroupSetCollapsed :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> Bool -> m ()

-- | Sets the ellipsization mode which should be used by labels in
--   <i><tt>group</tt></i>.
--   
--   <i>Since: 2.20</i>
toolItemGroupSetEllipsize :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> EllipsizeMode -> m ()

-- | Set the button relief of the group header. See <a>buttonSetRelief</a>
--   for details.
--   
--   <i>Since: 2.20</i>
toolItemGroupSetHeaderRelief :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> ReliefStyle -> m ()

-- | Sets the position of <i><tt>item</tt></i> in the list of children of
--   <i><tt>group</tt></i>.
--   
--   <i>Since: 2.20</i>
toolItemGroupSetItemPosition :: (HasCallStack, MonadIO m, IsToolItemGroup a, IsToolItem b) => a -> b -> Int32 -> m ()

-- | Sets the label of the tool item group. The label is displayed in the
--   header of the group.
--   
--   <i>Since: 2.20</i>
toolItemGroupSetLabel :: (HasCallStack, MonadIO m, IsToolItemGroup a) => a -> Text -> m ()

-- | Sets the label of the tool item group. The label widget is displayed
--   in the header of the group, in place of the usual label.
--   
--   <i>Since: 2.20</i>
toolItemGroupSetLabelWidget :: (HasCallStack, MonadIO m, IsToolItemGroup a, IsWidget b) => a -> b -> m ()

-- | Cast to <a>ToolPalette</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toToolPalette :: (MonadIO m, IsToolPalette o) => o -> m ToolPalette

-- | Get the value of the “<tt>icon-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolPalette #iconSize
--   </pre>
getToolPaletteIconSize :: (MonadIO m, IsToolPalette o) => o -> m IconSize

-- | Set the value of the “<tt>icon-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolPalette [ #iconSize <a>:=</a> value ]
--   </pre>
setToolPaletteIconSize :: (MonadIO m, IsToolPalette o) => o -> IconSize -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-size</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructToolPaletteIconSize :: (IsToolPalette o, MonadIO m) => IconSize -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon-size-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolPalette #iconSizeSet
--   </pre>
getToolPaletteIconSizeSet :: (MonadIO m, IsToolPalette o) => o -> m Bool

-- | Set the value of the “<tt>icon-size-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolPalette [ #iconSizeSet <a>:=</a> value ]
--   </pre>
setToolPaletteIconSizeSet :: (MonadIO m, IsToolPalette o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-size-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructToolPaletteIconSizeSet :: (IsToolPalette o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>toolbar-style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolPalette #toolbarStyle
--   </pre>
getToolPaletteToolbarStyle :: (MonadIO m, IsToolPalette o) => o -> m ToolbarStyle

-- | Set the value of the “<tt>toolbar-style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolPalette [ #toolbarStyle <a>:=</a> value ]
--   </pre>
setToolPaletteToolbarStyle :: (MonadIO m, IsToolPalette o) => o -> ToolbarStyle -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>toolbar-style</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructToolPaletteToolbarStyle :: (IsToolPalette o, MonadIO m) => ToolbarStyle -> m (GValueConstruct o)

-- | Creates a new tool palette.
--   
--   <i>Since: 2.20</i>
toolPaletteNew :: (HasCallStack, MonadIO m) => m ToolPalette

-- | Sets <i><tt>palette</tt></i> as drag source (see
--   <a>toolPaletteSetDragSource</a>) and sets <i><tt>widget</tt></i> as a
--   drag destination for drags from <i><tt>palette</tt></i>. See
--   <a>widgetDragDestSet</a>.
--   
--   <i>Since: 2.20</i>
toolPaletteAddDragDest :: (HasCallStack, MonadIO m, IsToolPalette a, IsWidget b) => a -> b -> [DestDefaults] -> [ToolPaletteDragTargets] -> [DragAction] -> m ()

-- | Get the dragged item from the selection. This could be a
--   <a>ToolItem</a> or a <a>ToolItemGroup</a>.
--   
--   <i>Since: 2.20</i>
toolPaletteGetDragItem :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> SelectionData -> m Widget

-- | Gets the group at position (x, y).
--   
--   <i>Since: 2.20</i>
toolPaletteGetDropGroup :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> Int32 -> Int32 -> m (Maybe ToolItemGroup)

-- | Gets the item at position (x, y). See <a>toolPaletteGetDropGroup</a>.
--   
--   <i>Since: 2.20</i>
toolPaletteGetDropItem :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> Int32 -> Int32 -> m (Maybe ToolItem)

-- | Gets whether <i><tt>group</tt></i> is exclusive or not. See
--   <a>toolPaletteSetExclusive</a>.
--   
--   <i>Since: 2.20</i>
toolPaletteGetExclusive :: (HasCallStack, MonadIO m, IsToolPalette a, IsToolItemGroup b) => a -> b -> m Bool

-- | Gets whether group should be given extra space. See
--   <a>toolPaletteSetExpand</a>.
--   
--   <i>Since: 2.20</i>
toolPaletteGetExpand :: (HasCallStack, MonadIO m, IsToolPalette a, IsToolItemGroup b) => a -> b -> m Bool

-- | Gets the position of <i><tt>group</tt></i> in <i><tt>palette</tt></i>
--   as index. See <a>toolPaletteSetGroupPosition</a>.
--   
--   <i>Since: 2.20</i>
toolPaletteGetGroupPosition :: (HasCallStack, MonadIO m, IsToolPalette a, IsToolItemGroup b) => a -> b -> m Int32

-- | Gets the horizontal adjustment of the tool palette.
--   
--   <i>Since: 2.20</i>
toolPaletteGetHadjustment :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> m Adjustment

-- | Gets the size of icons in the tool palette. See
--   <a>toolPaletteSetIconSize</a>.
--   
--   <i>Since: 2.20</i>
toolPaletteGetIconSize :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> m Int32

-- | Gets the style (icons, text or both) of items in the tool palette.
--   
--   <i>Since: 2.20</i>
toolPaletteGetStyle :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> m ToolbarStyle

-- | Gets the vertical adjustment of the tool palette.
--   
--   <i>Since: 2.20</i>
toolPaletteGetVadjustment :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> m Adjustment

-- | Sets the tool palette as a drag source. Enables all groups and items
--   in the tool palette as drag sources on button 1 and button 3 press
--   with copy and move actions. See <a>widgetDragSourceSet</a>.
--   
--   <i>Since: 2.20</i>
toolPaletteSetDragSource :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> [ToolPaletteDragTargets] -> m ()

-- | Sets whether the group should be exclusive or not. If an exclusive
--   group is expanded all other groups are collapsed.
--   
--   <i>Since: 2.20</i>
toolPaletteSetExclusive :: (HasCallStack, MonadIO m, IsToolPalette a, IsToolItemGroup b) => a -> b -> Bool -> m ()

-- | Sets whether the group should be given extra space.
--   
--   <i>Since: 2.20</i>
toolPaletteSetExpand :: (HasCallStack, MonadIO m, IsToolPalette a, IsToolItemGroup b) => a -> b -> Bool -> m ()

-- | Sets the position of the group as an index of the tool palette. If
--   position is 0 the group will become the first child, if position is -1
--   it will become the last child.
--   
--   <i>Since: 2.20</i>
toolPaletteSetGroupPosition :: (HasCallStack, MonadIO m, IsToolPalette a, IsToolItemGroup b) => a -> b -> Int32 -> m ()

-- | Sets the size of icons in the tool palette.
--   
--   <i>Since: 2.20</i>
toolPaletteSetIconSize :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> Int32 -> m ()

-- | Sets the style (text, icons or both) of items in the tool palette.
--   
--   <i>Since: 2.20</i>
toolPaletteSetStyle :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> ToolbarStyle -> m ()

-- | Unsets the tool palette icon size set with
--   <a>toolPaletteSetIconSize</a>, so that user preferences will be used
--   to determine the icon size.
--   
--   <i>Since: 2.20</i>
toolPaletteUnsetIconSize :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> m ()

-- | Unsets a toolbar style set with <a>toolPaletteSetStyle</a>, so that
--   user preferences will be used to determine the toolbar style.
--   
--   <i>Since: 2.20</i>
toolPaletteUnsetStyle :: (HasCallStack, MonadIO m, IsToolPalette a) => a -> m ()

-- | Get the target entry for a dragged <a>ToolItemGroup</a>.
--   
--   <i>Since: 2.20</i>
toolPaletteGetDragTargetGroup :: (HasCallStack, MonadIO m) => m TargetEntry

-- | Gets the target entry for a dragged <a>ToolItem</a>.
--   
--   <i>Since: 2.20</i>
toolPaletteGetDragTargetItem :: (HasCallStack, MonadIO m) => m TargetEntry

-- | Cast to <a>SeparatorToolItem</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toSeparatorToolItem :: (MonadIO m, IsSeparatorToolItem o) => o -> m SeparatorToolItem

-- | Get the value of the “<tt>draw</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> separatorToolItem #draw
--   </pre>
getSeparatorToolItemDraw :: (MonadIO m, IsSeparatorToolItem o) => o -> m Bool

-- | Set the value of the “<tt>draw</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> separatorToolItem [ #draw <a>:=</a> value ]
--   </pre>
setSeparatorToolItemDraw :: (MonadIO m, IsSeparatorToolItem o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>draw</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSeparatorToolItemDraw :: (IsSeparatorToolItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Create a new <a>SeparatorToolItem</a>
--   
--   <i>Since: 2.4</i>
separatorToolItemNew :: (HasCallStack, MonadIO m) => m SeparatorToolItem

-- | Returns whether <i><tt>item</tt></i> is drawn as a line, or just
--   blank. See <a>separatorToolItemSetDraw</a>.
--   
--   <i>Since: 2.4</i>
separatorToolItemGetDraw :: (HasCallStack, MonadIO m, IsSeparatorToolItem a) => a -> m Bool

-- | Whether <i><tt>item</tt></i> is drawn as a vertical line, or just
--   blank. Setting this to <a>False</a> along with
--   <a>toolItemSetExpand</a> is useful to create an item that forces
--   following items to the end of the toolbar.
--   
--   <i>Since: 2.4</i>
separatorToolItemSetDraw :: (HasCallStack, MonadIO m, IsSeparatorToolItem a) => a -> Bool -> m ()

-- | Cast to <a>ToolButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toToolButton :: (MonadIO m, IsToolButton o) => o -> m ToolButton

-- | Connect a signal handler for the <a>clicked</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> toolButton #clicked callback
--   </pre>
onToolButtonClicked :: (IsToolButton a, MonadIO m) => a -> ((?self :: a) => ToolButtonClickedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>clicked</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> toolButton #clicked callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterToolButtonClicked :: (IsToolButton a, MonadIO m) => a -> ((?self :: a) => ToolButtonClickedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolButton #iconName
--   </pre>
getToolButtonIconName :: (MonadIO m, IsToolButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolButton [ #iconName <a>:=</a> value ]
--   </pre>
setToolButtonIconName :: (MonadIO m, IsToolButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructToolButtonIconName :: (IsToolButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>icon-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #iconName
--   </pre>
clearToolButtonIconName :: (MonadIO m, IsToolButton o) => o -> m ()

-- | Get the value of the “<tt>icon-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolButton #iconWidget
--   </pre>
getToolButtonIconWidget :: (MonadIO m, IsToolButton o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>icon-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolButton [ #iconWidget <a>:=</a> value ]
--   </pre>
setToolButtonIconWidget :: (MonadIO m, IsToolButton o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-widget</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructToolButtonIconWidget :: (IsToolButton o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>icon-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #iconWidget
--   </pre>
clearToolButtonIconWidget :: (MonadIO m, IsToolButton o) => o -> m ()

-- | Get the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolButton #label
--   </pre>
getToolButtonLabel :: (MonadIO m, IsToolButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolButton [ #label <a>:=</a> value ]
--   </pre>
setToolButtonLabel :: (MonadIO m, IsToolButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructToolButtonLabel :: (IsToolButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>label</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #label
--   </pre>
clearToolButtonLabel :: (MonadIO m, IsToolButton o) => o -> m ()

-- | Get the value of the “<tt>label-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolButton #labelWidget
--   </pre>
getToolButtonLabelWidget :: (MonadIO m, IsToolButton o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>label-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolButton [ #labelWidget <a>:=</a> value ]
--   </pre>
setToolButtonLabelWidget :: (MonadIO m, IsToolButton o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label-widget</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructToolButtonLabelWidget :: (IsToolButton o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>label-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #labelWidget
--   </pre>
clearToolButtonLabelWidget :: (MonadIO m, IsToolButton o) => o -> m ()

-- | Get the value of the “<tt>stock-id</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolButton #stockId
--   </pre>
getToolButtonStockId :: (MonadIO m, IsToolButton o) => o -> m Text

-- | Set the value of the “<tt>stock-id</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolButton [ #stockId <a>:=</a> value ]
--   </pre>
setToolButtonStockId :: (MonadIO m, IsToolButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stock-id</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructToolButtonStockId :: (IsToolButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>stock-id</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #stockId
--   </pre>
clearToolButtonStockId :: (MonadIO m, IsToolButton o) => o -> m ()

-- | Get the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toolButton #useUnderline
--   </pre>
getToolButtonUseUnderline :: (MonadIO m, IsToolButton o) => o -> m Bool

-- | Set the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toolButton [ #useUnderline <a>:=</a> value ]
--   </pre>
setToolButtonUseUnderline :: (MonadIO m, IsToolButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-underline</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructToolButtonUseUnderline :: (IsToolButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>ToolButton</a> using <i><tt>iconWidget</tt></i> as
--   contents and <i><tt>label</tt></i> as label.
--   
--   <i>Since: 2.4</i>
toolButtonNew :: (HasCallStack, MonadIO m, IsWidget a) => Maybe a -> Maybe Text -> m ToolButton

-- | Creates a new <a>ToolButton</a> containing the image and text from a
--   stock item. Some stock ids have preprocessor macros like
--   <a>STOCK_OK</a> and <a>STOCK_APPLY</a>.
--   
--   It is an error if <i><tt>stockId</tt></i> is not a name of a stock
--   item.
--   
--   <i>Since: 2.4</i>
toolButtonNewFromStock :: (HasCallStack, MonadIO m) => Text -> m ToolButton

-- | Returns the name of the themed icon for the tool button, see
--   <a>toolButtonSetIconName</a>.
--   
--   <i>Since: 2.8</i>
toolButtonGetIconName :: (HasCallStack, MonadIO m, IsToolButton a) => a -> m (Maybe Text)

-- | Return the widget used as icon widget on <i><tt>button</tt></i>. See
--   <a>toolButtonSetIconWidget</a>.
--   
--   <i>Since: 2.4</i>
toolButtonGetIconWidget :: (HasCallStack, MonadIO m, IsToolButton a) => a -> m (Maybe Widget)

-- | Returns the label used by the tool button, or <a>Nothing</a> if the
--   tool button doesn’t have a label. or uses a the label from a stock
--   item. The returned string is owned by GTK+, and must not be modified
--   or freed.
--   
--   <i>Since: 2.4</i>
toolButtonGetLabel :: (HasCallStack, MonadIO m, IsToolButton a) => a -> m (Maybe Text)

-- | Returns the widget used as label on <i><tt>button</tt></i>. See
--   <a>toolButtonSetLabelWidget</a>.
--   
--   <i>Since: 2.4</i>
toolButtonGetLabelWidget :: (HasCallStack, MonadIO m, IsToolButton a) => a -> m (Maybe Widget)

-- | Returns the name of the stock item. See <a>toolButtonSetStockId</a>.
--   The returned string is owned by GTK+ and must not be freed or modifed.
--   
--   <i>Since: 2.4</i>
toolButtonGetStockId :: (HasCallStack, MonadIO m, IsToolButton a) => a -> m Text

-- | Returns whether underscores in the label property are used as
--   mnemonics on menu items on the overflow menu. See
--   <a>toolButtonSetUseUnderline</a>.
--   
--   <i>Since: 2.4</i>
toolButtonGetUseUnderline :: (HasCallStack, MonadIO m, IsToolButton a) => a -> m Bool

-- | Sets the icon for the tool button from a named themed icon. See the
--   docs for <a>IconTheme</a> for more details. The
--   <a>ToolButton:iconName</a> property only has an effect if not
--   overridden by non-<a>Nothing</a> <a>ToolButton:labelWidget</a>,
--   <a>ToolButton:iconWidget</a> and <a>ToolButton:stockId</a> properties.
--   
--   <i>Since: 2.8</i>
toolButtonSetIconName :: (HasCallStack, MonadIO m, IsToolButton a) => a -> Maybe Text -> m ()

-- | Sets <i><tt>icon</tt></i> as the widget used as icon on
--   <i><tt>button</tt></i>. If <i><tt>iconWidget</tt></i> is
--   <a>Nothing</a> the icon is determined by the <a>ToolButton:stockId</a>
--   property. If the <a>ToolButton:stockId</a> property is also
--   <a>Nothing</a>, <i><tt>button</tt></i> will not have an icon.
--   
--   <i>Since: 2.4</i>
toolButtonSetIconWidget :: (HasCallStack, MonadIO m, IsToolButton a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets <i><tt>label</tt></i> as the label used for the tool button. The
--   <a>ToolButton:label</a> property only has an effect if not overridden
--   by a non-<a>Nothing</a> <a>ToolButton:labelWidget</a> property. If
--   both the <a>ToolButton:labelWidget</a> and <a>ToolButton:label</a>
--   properties are <a>Nothing</a>, the label is determined by the
--   <a>ToolButton:stockId</a> property. If the <a>ToolButton:stockId</a>
--   property is also <a>Nothing</a>, <i><tt>button</tt></i> will not have
--   a label.
--   
--   <i>Since: 2.4</i>
toolButtonSetLabel :: (HasCallStack, MonadIO m, IsToolButton a) => a -> Maybe Text -> m ()

-- | Sets <i><tt>labelWidget</tt></i> as the widget that will be used as
--   the label for <i><tt>button</tt></i>. If <i><tt>labelWidget</tt></i>
--   is <a>Nothing</a> the <a>ToolButton:label</a> property is used as
--   label. If <a>ToolButton:label</a> is also <a>Nothing</a>, the label in
--   the stock item determined by the <a>ToolButton:stockId</a> property is
--   used as label. If <a>ToolButton:stockId</a> is also <a>Nothing</a>,
--   <i><tt>button</tt></i> does not have a label.
--   
--   <i>Since: 2.4</i>
toolButtonSetLabelWidget :: (HasCallStack, MonadIO m, IsToolButton a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the name of the stock item. See <a>toolButtonNewFromStock</a>.
--   The stock_id property only has an effect if not overridden by
--   non-<a>Nothing</a> <a>ToolButton:labelWidget</a> and
--   <a>ToolButton:iconWidget</a> properties.
--   
--   <i>Since: 2.4</i>
toolButtonSetStockId :: (HasCallStack, MonadIO m, IsToolButton a) => a -> Maybe Text -> m ()

-- | If set, an underline in the label property indicates that the next
--   character should be used for the mnemonic accelerator key in the
--   overflow menu. For example, if the label property is “_Open” and
--   <i><tt>useUnderline</tt></i> is <a>True</a>, the label on the tool
--   button will be “Open” and the item on the overflow menu will have an
--   underlined “O”.
--   
--   Labels shown on tool buttons never have mnemonics on them; this
--   property only affects the menu item on the overflow menu.
--   
--   <i>Since: 2.4</i>
toolButtonSetUseUnderline :: (HasCallStack, MonadIO m, IsToolButton a) => a -> Bool -> m ()

-- | Cast to <a>ToggleToolButton</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toToggleToolButton :: (MonadIO m, IsToggleToolButton o) => o -> m ToggleToolButton

-- | Connect a signal handler for the <a>toggled</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> toggleToolButton #toggled callback
--   </pre>
onToggleToolButtonToggled :: (IsToggleToolButton a, MonadIO m) => a -> ((?self :: a) => ToggleToolButtonToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggled</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> toggleToolButton #toggled callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterToggleToolButtonToggled :: (IsToggleToolButton a, MonadIO m) => a -> ((?self :: a) => ToggleToolButtonToggledCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toggleToolButton #active
--   </pre>
getToggleToolButtonActive :: (MonadIO m, IsToggleToolButton o) => o -> m Bool

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toggleToolButton [ #active <a>:=</a> value ]
--   </pre>
setToggleToolButtonActive :: (MonadIO m, IsToggleToolButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructToggleToolButtonActive :: (IsToggleToolButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Returns a new <a>ToggleToolButton</a>
--   
--   <i>Since: 2.4</i>
toggleToolButtonNew :: (HasCallStack, MonadIO m) => m ToggleToolButton

-- | Creates a new <a>ToggleToolButton</a> containing the image and text
--   from a stock item. Some stock ids have preprocessor macros like
--   <a>STOCK_OK</a> and <a>STOCK_APPLY</a>.
--   
--   It is an error if <i><tt>stockId</tt></i> is not a name of a stock
--   item.
--   
--   <i>Since: 2.4</i>
toggleToolButtonNewFromStock :: (HasCallStack, MonadIO m) => Text -> m ToggleToolButton

-- | Queries a <a>ToggleToolButton</a> and returns its current state.
--   Returns <a>True</a> if the toggle button is pressed in and
--   <a>False</a> if it is raised.
--   
--   <i>Since: 2.4</i>
toggleToolButtonGetActive :: (HasCallStack, MonadIO m, IsToggleToolButton a) => a -> m Bool

-- | Sets the status of the toggle tool button. Set to <a>True</a> if you
--   want the GtkToggleButton to be “pressed in”, and <a>False</a> to raise
--   it. This action causes the toggled signal to be emitted.
--   
--   <i>Since: 2.4</i>
toggleToolButtonSetActive :: (HasCallStack, MonadIO m, IsToggleToolButton a) => a -> Bool -> m ()

-- | Cast to <a>Switch</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toSwitch :: (MonadIO m, IsSwitch o) => o -> m Switch

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> switch #activate callback
--   </pre>
onSwitchActivate :: (IsSwitch a, MonadIO m) => a -> ((?self :: a) => SwitchActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> switch #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSwitchActivate :: (IsSwitch a, MonadIO m) => a -> ((?self :: a) => SwitchActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>stateSet</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> switch #stateSet callback
--   </pre>
onSwitchStateSet :: (IsSwitch a, MonadIO m) => a -> ((?self :: a) => SwitchStateSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>stateSet</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> switch #stateSet callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSwitchStateSet :: (IsSwitch a, MonadIO m) => a -> ((?self :: a) => SwitchStateSetCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> switch #active
--   </pre>
getSwitchActive :: (MonadIO m, IsSwitch o) => o -> m Bool

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> switch [ #active <a>:=</a> value ]
--   </pre>
setSwitchActive :: (MonadIO m, IsSwitch o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSwitchActive :: (IsSwitch o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>state</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> switch #state
--   </pre>
getSwitchState :: (MonadIO m, IsSwitch o) => o -> m Bool

-- | Set the value of the “<tt>state</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> switch [ #state <a>:=</a> value ]
--   </pre>
setSwitchState :: (MonadIO m, IsSwitch o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>state</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSwitchState :: (IsSwitch o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>Switch</a> widget.
--   
--   <i>Since: 3.0</i>
switchNew :: (HasCallStack, MonadIO m) => m Switch

-- | Gets whether the <a>Switch</a> is in its “on” or “off” state.
--   
--   <i>Since: 3.0</i>
switchGetActive :: (HasCallStack, MonadIO m, IsSwitch a) => a -> m Bool

-- | Gets the underlying state of the <a>Switch</a>.
--   
--   <i>Since: 3.14</i>
switchGetState :: (HasCallStack, MonadIO m, IsSwitch a) => a -> m Bool

-- | Changes the state of <i><tt>sw</tt></i> to the desired one.
--   
--   <i>Since: 3.0</i>
switchSetActive :: (HasCallStack, MonadIO m, IsSwitch a) => a -> Bool -> m ()

-- | Sets the underlying state of the <a>Switch</a>.
--   
--   Normally, this is the same as <a>Switch:active</a>, unless the switch
--   is set up for delayed state changes. This function is typically called
--   from a <a>Switch::stateSet</a> signal handler.
--   
--   See <a>Switch::stateSet</a> for details.
--   
--   <i>Since: 3.14</i>
switchSetState :: (HasCallStack, MonadIO m, IsSwitch a) => a -> Bool -> m ()

-- | Cast to <a>TearoffMenuItem</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toTearoffMenuItem :: (MonadIO m, IsTearoffMenuItem o) => o -> m TearoffMenuItem

-- | Creates a new <a>TearoffMenuItem</a>.
tearoffMenuItemNew :: (HasCallStack, MonadIO m) => m TearoffMenuItem

-- | Cast to <a>StatusIcon</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toStatusIcon :: (MonadIO m, IsStatusIcon o) => o -> m StatusIcon

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> statusIcon #activate callback
--   </pre>
onStatusIconActivate :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> statusIcon #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterStatusIconActivate :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>buttonPressEvent</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> statusIcon #buttonPressEvent callback
--   </pre>
onStatusIconButtonPressEvent :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconButtonPressEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>buttonPressEvent</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> statusIcon #buttonPressEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterStatusIconButtonPressEvent :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconButtonPressEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>buttonReleaseEvent</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> statusIcon #buttonReleaseEvent callback
--   </pre>
onStatusIconButtonReleaseEvent :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconButtonReleaseEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>buttonReleaseEvent</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> statusIcon #buttonReleaseEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterStatusIconButtonReleaseEvent :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconButtonReleaseEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popupMenu</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> statusIcon #popupMenu callback
--   </pre>
onStatusIconPopupMenu :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconPopupMenuCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popupMenu</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> statusIcon #popupMenu callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterStatusIconPopupMenu :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconPopupMenuCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>queryTooltip</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> statusIcon #queryTooltip callback
--   </pre>
onStatusIconQueryTooltip :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconQueryTooltipCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>queryTooltip</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> statusIcon #queryTooltip callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterStatusIconQueryTooltip :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconQueryTooltipCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scrollEvent</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> statusIcon #scrollEvent callback
--   </pre>
onStatusIconScrollEvent :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconScrollEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scrollEvent</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> statusIcon #scrollEvent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterStatusIconScrollEvent :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconScrollEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>sizeChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> statusIcon #sizeChanged callback
--   </pre>
onStatusIconSizeChanged :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconSizeChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>sizeChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> statusIcon #sizeChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterStatusIconSizeChanged :: (IsStatusIcon a, MonadIO m) => a -> ((?self :: a) => StatusIconSizeChangedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>embedded</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> statusIcon #embedded
--   </pre>
getStatusIconEmbedded :: (MonadIO m, IsStatusIcon o) => o -> m Bool

-- | Set the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> statusIcon [ #file <a>:=</a> value ]
--   </pre>
setStatusIconFile :: (MonadIO m, IsStatusIcon o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>file</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStatusIconFile :: (IsStatusIcon o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>file</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #file
--   </pre>
clearStatusIconFile :: (MonadIO m, IsStatusIcon o) => o -> m ()

-- | Get the value of the “<tt>gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> statusIcon #gicon
--   </pre>
getStatusIconGicon :: (MonadIO m, IsStatusIcon o) => o -> m (Maybe Icon)

-- | Set the value of the “<tt>gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> statusIcon [ #gicon <a>:=</a> value ]
--   </pre>
setStatusIconGicon :: (MonadIO m, IsStatusIcon o, IsIcon a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gicon</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStatusIconGicon :: (IsStatusIcon o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>gicon</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #gicon
--   </pre>
clearStatusIconGicon :: (MonadIO m, IsStatusIcon o) => o -> m ()

-- | Get the value of the “<tt>has-tooltip</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> statusIcon #hasTooltip
--   </pre>
getStatusIconHasTooltip :: (MonadIO m, IsStatusIcon o) => o -> m Bool

-- | Set the value of the “<tt>has-tooltip</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> statusIcon [ #hasTooltip <a>:=</a> value ]
--   </pre>
setStatusIconHasTooltip :: (MonadIO m, IsStatusIcon o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-tooltip</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructStatusIconHasTooltip :: (IsStatusIcon o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> statusIcon #iconName
--   </pre>
getStatusIconIconName :: (MonadIO m, IsStatusIcon o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> statusIcon [ #iconName <a>:=</a> value ]
--   </pre>
setStatusIconIconName :: (MonadIO m, IsStatusIcon o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructStatusIconIconName :: (IsStatusIcon o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>icon-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #iconName
--   </pre>
clearStatusIconIconName :: (MonadIO m, IsStatusIcon o) => o -> m ()

-- | Get the value of the “<tt>orientation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> statusIcon #orientation
--   </pre>
getStatusIconOrientation :: (MonadIO m, IsStatusIcon o) => o -> m Orientation

-- | Get the value of the “<tt>pixbuf</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> statusIcon #pixbuf
--   </pre>
getStatusIconPixbuf :: (MonadIO m, IsStatusIcon o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “<tt>pixbuf</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> statusIcon [ #pixbuf <a>:=</a> value ]
--   </pre>
setStatusIconPixbuf :: (MonadIO m, IsStatusIcon o, IsPixbuf a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixbuf</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStatusIconPixbuf :: (IsStatusIcon o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>pixbuf</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #pixbuf
--   </pre>
clearStatusIconPixbuf :: (MonadIO m, IsStatusIcon o) => o -> m ()

-- | Get the value of the “<tt>screen</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> statusIcon #screen
--   </pre>
getStatusIconScreen :: (MonadIO m, IsStatusIcon o) => o -> m Screen

-- | Set the value of the “<tt>screen</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> statusIcon [ #screen <a>:=</a> value ]
--   </pre>
setStatusIconScreen :: (MonadIO m, IsStatusIcon o, IsScreen a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>screen</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStatusIconScreen :: (IsStatusIcon o, MonadIO m, IsScreen a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> statusIcon #size
--   </pre>
getStatusIconSize :: (MonadIO m, IsStatusIcon o) => o -> m Int32

-- | Get the value of the “<tt>stock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> statusIcon #stock
--   </pre>
getStatusIconStock :: (MonadIO m, IsStatusIcon o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>stock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> statusIcon [ #stock <a>:=</a> value ]
--   </pre>
setStatusIconStock :: (MonadIO m, IsStatusIcon o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stock</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStatusIconStock :: (IsStatusIcon o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>stock</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #stock
--   </pre>
clearStatusIconStock :: (MonadIO m, IsStatusIcon o) => o -> m ()

-- | Get the value of the “<tt>storage-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> statusIcon #storageType
--   </pre>
getStatusIconStorageType :: (MonadIO m, IsStatusIcon o) => o -> m ImageType

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> statusIcon #title
--   </pre>
getStatusIconTitle :: (MonadIO m, IsStatusIcon o) => o -> m Text

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> statusIcon [ #title <a>:=</a> value ]
--   </pre>
setStatusIconTitle :: (MonadIO m, IsStatusIcon o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStatusIconTitle :: (IsStatusIcon o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>tooltip-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> statusIcon #tooltipMarkup
--   </pre>
getStatusIconTooltipMarkup :: (MonadIO m, IsStatusIcon o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>tooltip-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> statusIcon [ #tooltipMarkup <a>:=</a> value ]
--   </pre>
setStatusIconTooltipMarkup :: (MonadIO m, IsStatusIcon o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip-markup</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructStatusIconTooltipMarkup :: (IsStatusIcon o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>tooltip-markup</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #tooltipMarkup
--   </pre>
clearStatusIconTooltipMarkup :: (MonadIO m, IsStatusIcon o) => o -> m ()

-- | Get the value of the “<tt>tooltip-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> statusIcon #tooltipText
--   </pre>
getStatusIconTooltipText :: (MonadIO m, IsStatusIcon o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>tooltip-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> statusIcon [ #tooltipText <a>:=</a> value ]
--   </pre>
setStatusIconTooltipText :: (MonadIO m, IsStatusIcon o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip-text</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructStatusIconTooltipText :: (IsStatusIcon o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> statusIcon #visible
--   </pre>
getStatusIconVisible :: (MonadIO m, IsStatusIcon o) => o -> m Bool

-- | Set the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> statusIcon [ #visible <a>:=</a> value ]
--   </pre>
setStatusIconVisible :: (MonadIO m, IsStatusIcon o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStatusIconVisible :: (IsStatusIcon o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates an empty status icon object.
--   
--   <i>Since: 2.10</i>
statusIconNew :: (HasCallStack, MonadIO m) => m StatusIcon

-- | Creates a status icon displaying the file <i><tt>filename</tt></i>.
--   
--   The image will be scaled down to fit in the available space in the
--   notification area, if necessary.
--   
--   <i>Since: 2.10</i>
statusIconNewFromFile :: (HasCallStack, MonadIO m) => [Char] -> m StatusIcon

-- | Creates a status icon displaying a <a>Icon</a>. If the icon is a
--   themed icon, it will be updated when the theme changes.
--   
--   <i>Since: 2.14</i>
statusIconNewFromGicon :: (HasCallStack, MonadIO m, IsIcon a) => a -> m StatusIcon

-- | Creates a status icon displaying an icon from the current icon theme.
--   If the current icon theme is changed, the icon will be updated
--   appropriately.
--   
--   <i>Since: 2.10</i>
statusIconNewFromIconName :: (HasCallStack, MonadIO m) => Text -> m StatusIcon

-- | Creates a status icon displaying <i><tt>pixbuf</tt></i>.
--   
--   The image will be scaled down to fit in the available space in the
--   notification area, if necessary.
--   
--   <i>Since: 2.10</i>
statusIconNewFromPixbuf :: (HasCallStack, MonadIO m, IsPixbuf a) => a -> m StatusIcon

-- | Creates a status icon displaying a stock icon. Sample stock icon names
--   are <a>STOCK_OPEN</a>, <a>STOCK_QUIT</a>. You can register your own
--   stock icon names, see <a>iconFactoryAddDefault</a> and
--   <a>iconFactoryAdd</a>.
--   
--   <i>Since: 2.10</i>
statusIconNewFromStock :: (HasCallStack, MonadIO m) => Text -> m StatusIcon

-- | Obtains information about the location of the status icon on screen.
--   This information can be used to e.g. position popups like notification
--   bubbles.
--   
--   See <a>statusIconPositionMenu</a> for a more convenient alternative
--   for positioning menus.
--   
--   Note that some platforms do not allow GTK+ to provide this
--   information, and even on platforms that do allow it, the information
--   is not reliable unless the status icon is embedded in a notification
--   area, see <a>statusIconIsEmbedded</a>.
--   
--   <i>Since: 2.10</i>
statusIconGetGeometry :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m (Bool, Screen, Rectangle, Orientation)

-- | Retrieves the <a>Icon</a> being displayed by the <a>StatusIcon</a>.
--   The storage type of the status icon must be <a>ImageTypeEmpty</a> or
--   <a>ImageTypeGicon</a> (see <a>statusIconGetStorageType</a>). The
--   caller of this function does not own a reference to the returned
--   <a>Icon</a>.
--   
--   If this function fails, <i><tt>icon</tt></i> is left unchanged;
--   
--   <i>Since: 2.14</i>
statusIconGetGicon :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m (Maybe Icon)

-- | Returns the current value of the has-tooltip property. See
--   <a>StatusIcon:hasTooltip</a> for more information.
--   
--   <i>Since: 2.16</i>
statusIconGetHasTooltip :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m Bool

-- | Gets the name of the icon being displayed by the <a>StatusIcon</a>.
--   The storage type of the status icon must be <a>ImageTypeEmpty</a> or
--   <a>ImageTypeIconName</a> (see <a>statusIconGetStorageType</a>). The
--   returned string is owned by the <a>StatusIcon</a> and should not be
--   freed or modified.
--   
--   <i>Since: 2.10</i>
statusIconGetIconName :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m (Maybe Text)

-- | Gets the <a>Pixbuf</a> being displayed by the <a>StatusIcon</a>. The
--   storage type of the status icon must be <a>ImageTypeEmpty</a> or
--   <a>ImageTypePixbuf</a> (see <a>statusIconGetStorageType</a>). The
--   caller of this function does not own a reference to the returned
--   pixbuf.
--   
--   <i>Since: 2.10</i>
statusIconGetPixbuf :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m (Maybe Pixbuf)

-- | Returns the <a>Screen</a> associated with <i><tt>statusIcon</tt></i>.
--   
--   <i>Since: 2.12</i>
statusIconGetScreen :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m Screen

-- | Gets the size in pixels that is available for the image. Stock icons
--   and named icons adapt their size automatically if the size of the
--   notification area changes. For other storage types, the size-changed
--   signal can be used to react to size changes.
--   
--   Note that the returned size is only meaningful while the status icon
--   is embedded (see <a>statusIconIsEmbedded</a>).
--   
--   <i>Since: 2.10</i>
statusIconGetSize :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m Int32

-- | Gets the id of the stock icon being displayed by the
--   <a>StatusIcon</a>. The storage type of the status icon must be
--   <a>ImageTypeEmpty</a> or <a>ImageTypeStock</a> (see
--   <a>statusIconGetStorageType</a>). The returned string is owned by the
--   <a>StatusIcon</a> and should not be freed or modified.
--   
--   <i>Since: 2.10</i>
statusIconGetStock :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m (Maybe Text)

-- | Gets the type of representation being used by the <a>StatusIcon</a> to
--   store image data. If the <a>StatusIcon</a> has no image data, the
--   return value will be <a>ImageTypeEmpty</a>.
--   
--   <i>Since: 2.10</i>
statusIconGetStorageType :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m ImageType

-- | Gets the title of this tray icon. See <a>statusIconSetTitle</a>.
--   
--   <i>Since: 2.18</i>
statusIconGetTitle :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m Text

-- | Gets the contents of the tooltip for <i><tt>statusIcon</tt></i>.
--   
--   <i>Since: 2.16</i>
statusIconGetTooltipMarkup :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m (Maybe Text)

-- | Gets the contents of the tooltip for <i><tt>statusIcon</tt></i>.
--   
--   <i>Since: 2.16</i>
statusIconGetTooltipText :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m (Maybe Text)

-- | Returns whether the status icon is visible or not. Note that being
--   visible does not guarantee that the user can actually see the icon,
--   see also <a>statusIconIsEmbedded</a>.
--   
--   <i>Since: 2.10</i>
statusIconGetVisible :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m Bool

-- | This function is only useful on the X11/freedesktop.org platform.
--   
--   It returns a window ID for the widget in the underlying status icon
--   implementation. This is useful for the Galago notification service,
--   which can send a window ID in the protocol in order for the server to
--   position notification windows pointing to a status icon reliably.
--   
--   This function is not intended for other use cases which are more
--   likely to be met by one of the non-X11 specific methods, such as
--   <a>statusIconPositionMenu</a>.
--   
--   <i>Since: 2.14</i>
statusIconGetX11WindowId :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m Word32

-- | Returns whether the status icon is embedded in a notification area.
--   
--   <i>Since: 2.10</i>
statusIconIsEmbedded :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> m Bool

-- | Makes <i><tt>statusIcon</tt></i> display the file
--   <i><tt>filename</tt></i>. See <a>statusIconNewFromFile</a> for
--   details.
--   
--   <i>Since: 2.10</i>
statusIconSetFromFile :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> [Char] -> m ()

-- | Makes <i><tt>statusIcon</tt></i> display the <a>Icon</a>. See
--   <a>statusIconNewFromGicon</a> for details.
--   
--   <i>Since: 2.14</i>
statusIconSetFromGicon :: (HasCallStack, MonadIO m, IsStatusIcon a, IsIcon b) => a -> b -> m ()

-- | Makes <i><tt>statusIcon</tt></i> display the icon named
--   <i><tt>iconName</tt></i> from the current icon theme. See
--   <a>statusIconNewFromIconName</a> for details.
--   
--   <i>Since: 2.10</i>
statusIconSetFromIconName :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Text -> m ()

-- | Makes <i><tt>statusIcon</tt></i> display <i><tt>pixbuf</tt></i>. See
--   <a>statusIconNewFromPixbuf</a> for details.
--   
--   <i>Since: 2.10</i>
statusIconSetFromPixbuf :: (HasCallStack, MonadIO m, IsStatusIcon a, IsPixbuf b) => a -> Maybe b -> m ()

-- | Makes <i><tt>statusIcon</tt></i> display the stock icon with the id
--   <i><tt>stockId</tt></i>. See <a>statusIconNewFromStock</a> for
--   details.
--   
--   <i>Since: 2.10</i>
statusIconSetFromStock :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Text -> m ()

-- | Sets the has-tooltip property on <i><tt>statusIcon</tt></i> to
--   <i><tt>hasTooltip</tt></i>. See <a>StatusIcon:hasTooltip</a> for more
--   information.
--   
--   <i>Since: 2.16</i>
statusIconSetHasTooltip :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Bool -> m ()

-- | Sets the name of this tray icon. This should be a string identifying
--   this icon. It is may be used for sorting the icons in the tray and
--   will not be shown to the user.
--   
--   <i>Since: 2.20</i>
statusIconSetName :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Text -> m ()

-- | Sets the <a>Screen</a> where <i><tt>statusIcon</tt></i> is displayed;
--   if the icon is already mapped, it will be unmapped, and then remapped
--   on the new screen.
--   
--   <i>Since: 2.12</i>
statusIconSetScreen :: (HasCallStack, MonadIO m, IsStatusIcon a, IsScreen b) => a -> b -> m ()

-- | Sets the title of this tray icon. This should be a short,
--   human-readable, localized string describing the tray icon. It may be
--   used by tools like screen readers to render the tray icon.
--   
--   <i>Since: 2.18</i>
statusIconSetTitle :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Text -> m ()

-- | Sets <i><tt>markup</tt></i> as the contents of the tooltip, which is
--   marked up with the [Pango text markup language][PangoMarkupFormat].
--   
--   This function will take care of setting <a>StatusIcon:hasTooltip</a>
--   to <a>True</a> and of the default handler for the
--   <a>StatusIcon::queryTooltip</a> signal.
--   
--   See also the <a>StatusIcon:tooltipMarkup</a> property and
--   <a>tooltipSetMarkup</a>.
--   
--   <i>Since: 2.16</i>
statusIconSetTooltipMarkup :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Maybe Text -> m ()

-- | Sets <i><tt>text</tt></i> as the contents of the tooltip.
--   
--   This function will take care of setting <a>StatusIcon:hasTooltip</a>
--   to <a>True</a> and of the default handler for the
--   <a>StatusIcon::queryTooltip</a> signal.
--   
--   See also the <a>StatusIcon:tooltipText</a> property and
--   <a>tooltipSetText</a>.
--   
--   <i>Since: 2.16</i>
statusIconSetTooltipText :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Text -> m ()

-- | Shows or hides a status icon.
--   
--   <i>Since: 2.10</i>
statusIconSetVisible :: (HasCallStack, MonadIO m, IsStatusIcon a) => a -> Bool -> m ()

-- | Menu positioning function to use with <a>menuPopup</a> to position
--   <i><tt>menu</tt></i> aligned to the status icon
--   <i><tt>userData</tt></i>.
--   
--   <i>Since: 2.10</i>
statusIconPositionMenu :: (HasCallStack, MonadIO m, IsMenu a, IsStatusIcon b) => a -> Int32 -> Int32 -> b -> m (Int32, Int32, Bool)

-- | Cast to <a>SeparatorMenuItem</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toSeparatorMenuItem :: (MonadIO m, IsSeparatorMenuItem o) => o -> m SeparatorMenuItem

-- | Creates a new <a>SeparatorMenuItem</a>.
separatorMenuItemNew :: (HasCallStack, MonadIO m) => m SeparatorMenuItem

-- | Cast to <a>RecentChooserMenu</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toRecentChooserMenu :: (MonadIO m, IsRecentChooserMenu o) => o -> m RecentChooserMenu

-- | Get the value of the “<tt>show-numbers</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentChooserMenu #showNumbers
--   </pre>
getRecentChooserMenuShowNumbers :: (MonadIO m, IsRecentChooserMenu o) => o -> m Bool

-- | Set the value of the “<tt>show-numbers</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentChooserMenu [ #showNumbers <a>:=</a> value ]
--   </pre>
setRecentChooserMenuShowNumbers :: (MonadIO m, IsRecentChooserMenu o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-numbers</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructRecentChooserMenuShowNumbers :: (IsRecentChooserMenu o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>RecentChooserMenu</a> widget.
--   
--   This kind of widget shows the list of recently used resources as a
--   menu, each item as a menu item. Each item inside the menu might have
--   an icon, representing its MIME type, and a number, for mnemonic
--   access.
--   
--   This widget implements the <a>RecentChooser</a> interface.
--   
--   This widget creates its own <a>RecentManager</a> object. See the
--   <a>recentChooserMenuNewForManager</a> function to know how to create a
--   <a>RecentChooserMenu</a> widget bound to another <a>RecentManager</a>
--   object.
--   
--   <i>Since: 2.10</i>
recentChooserMenuNew :: (HasCallStack, MonadIO m) => m RecentChooserMenu

-- | Creates a new <a>RecentChooserMenu</a> widget using
--   <i><tt>manager</tt></i> as the underlying recently used resources
--   manager.
--   
--   This is useful if you have implemented your own recent manager, or if
--   you have a customized instance of a <a>RecentManager</a> object or if
--   you wish to share a common <a>RecentManager</a> object among multiple
--   <a>RecentChooser</a> widgets.
--   
--   <i>Since: 2.10</i>
recentChooserMenuNewForManager :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> m RecentChooserMenu

-- | Returns the value set by <a>recentChooserMenuSetShowNumbers</a>.
--   
--   <i>Since: 2.10</i>
recentChooserMenuGetShowNumbers :: (HasCallStack, MonadIO m, IsRecentChooserMenu a) => a -> m Bool

-- | Cast to <a>MenuToolButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMenuToolButton :: (MonadIO m, IsMenuToolButton o) => o -> m MenuToolButton

-- | Connect a signal handler for the <a>showMenu</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> menuToolButton #showMenu callback
--   </pre>
onMenuToolButtonShowMenu :: (IsMenuToolButton a, MonadIO m) => a -> ((?self :: a) => MenuToolButtonShowMenuCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showMenu</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> menuToolButton #showMenu callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuToolButtonShowMenu :: (IsMenuToolButton a, MonadIO m) => a -> ((?self :: a) => MenuToolButtonShowMenuCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>menu</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuToolButton #menu
--   </pre>
getMenuToolButtonMenu :: (MonadIO m, IsMenuToolButton o) => o -> m (Maybe Menu)

-- | Set the value of the “<tt>menu</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuToolButton [ #menu <a>:=</a> value ]
--   </pre>
setMenuToolButtonMenu :: (MonadIO m, IsMenuToolButton o, IsMenu a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>menu</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMenuToolButtonMenu :: (IsMenuToolButton o, MonadIO m, IsMenu a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>menu</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #menu
--   </pre>
clearMenuToolButtonMenu :: (MonadIO m, IsMenuToolButton o) => o -> m ()

-- | Creates a new <a>MenuToolButton</a> using <i><tt>iconWidget</tt></i>
--   as icon and <i><tt>label</tt></i> as label.
--   
--   <i>Since: 2.6</i>
menuToolButtonNew :: (HasCallStack, MonadIO m, IsWidget a) => Maybe a -> Maybe Text -> m MenuToolButton

-- | Creates a new <a>MenuToolButton</a>. The new <a>MenuToolButton</a>
--   will contain an icon and label from the stock item indicated by
--   <i><tt>stockId</tt></i>.
--   
--   <i>Since: 2.6</i>
menuToolButtonNewFromStock :: (HasCallStack, MonadIO m) => Text -> m MenuToolButton

-- | Gets the <a>Menu</a> associated with <a>MenuToolButton</a>.
--   
--   <i>Since: 2.6</i>
menuToolButtonGetMenu :: (HasCallStack, MonadIO m, IsMenuToolButton a) => a -> m Widget

-- | Sets the tooltip markup text to be used as tooltip for the arrow
--   button which pops up the menu. See <a>toolItemSetTooltipText</a> for
--   setting a tooltip on the whole <a>MenuToolButton</a>.
--   
--   <i>Since: 2.12</i>
menuToolButtonSetArrowTooltipMarkup :: (HasCallStack, MonadIO m, IsMenuToolButton a) => a -> Text -> m ()

-- | Sets the tooltip text to be used as tooltip for the arrow button which
--   pops up the menu. See <a>toolItemSetTooltipText</a> for setting a
--   tooltip on the whole <a>MenuToolButton</a>.
--   
--   <i>Since: 2.12</i>
menuToolButtonSetArrowTooltipText :: (HasCallStack, MonadIO m, IsMenuToolButton a) => a -> Text -> m ()

-- | Sets the <a>Menu</a> that is popped up when the user clicks on the
--   arrow. If <i><tt>menu</tt></i> is NULL, the arrow button becomes
--   insensitive.
--   
--   <i>Since: 2.6</i>
menuToolButtonSetMenu :: (HasCallStack, MonadIO m, IsMenuToolButton a, IsWidget b) => a -> b -> m ()

-- | Cast to <a>MenuBar</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toMenuBar :: (MonadIO m, IsMenuBar o) => o -> m MenuBar

-- | Get the value of the “<tt>child-pack-direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuBar #childPackDirection
--   </pre>
getMenuBarChildPackDirection :: (MonadIO m, IsMenuBar o) => o -> m PackDirection

-- | Set the value of the “<tt>child-pack-direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuBar [ #childPackDirection <a>:=</a> value ]
--   </pre>
setMenuBarChildPackDirection :: (MonadIO m, IsMenuBar o) => o -> PackDirection -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child-pack-direction</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructMenuBarChildPackDirection :: (IsMenuBar o, MonadIO m) => PackDirection -> m (GValueConstruct o)

-- | Get the value of the “<tt>pack-direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuBar #packDirection
--   </pre>
getMenuBarPackDirection :: (MonadIO m, IsMenuBar o) => o -> m PackDirection

-- | Set the value of the “<tt>pack-direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuBar [ #packDirection <a>:=</a> value ]
--   </pre>
setMenuBarPackDirection :: (MonadIO m, IsMenuBar o) => o -> PackDirection -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pack-direction</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructMenuBarPackDirection :: (IsMenuBar o, MonadIO m) => PackDirection -> m (GValueConstruct o)

-- | Creates a new <a>MenuBar</a>
menuBarNew :: (HasCallStack, MonadIO m) => m MenuBar

-- | Retrieves the current child pack direction of the menubar. See
--   <a>menuBarSetChildPackDirection</a>.
--   
--   <i>Since: 2.8</i>
menuBarGetChildPackDirection :: (HasCallStack, MonadIO m, IsMenuBar a) => a -> m PackDirection

-- | Retrieves the current pack direction of the menubar. See
--   <a>menuBarSetPackDirection</a>.
--   
--   <i>Since: 2.8</i>
menuBarGetPackDirection :: (HasCallStack, MonadIO m, IsMenuBar a) => a -> m PackDirection

-- | Sets how widgets should be packed inside the children of a menubar.
--   
--   <i>Since: 2.8</i>
menuBarSetChildPackDirection :: (HasCallStack, MonadIO m, IsMenuBar a) => a -> PackDirection -> m ()

-- | Sets how items should be packed inside a menubar.
--   
--   <i>Since: 2.8</i>
menuBarSetPackDirection :: (HasCallStack, MonadIO m, IsMenuBar a) => a -> PackDirection -> m ()

-- | Cast to <a>Label</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toLabel :: (MonadIO m, IsLabel o) => o -> m Label

-- | Connect a signal handler for the <a>activateCurrentLink</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> label #activateCurrentLink callback
--   </pre>
onLabelActivateCurrentLink :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelActivateCurrentLinkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateCurrentLink</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> label #activateCurrentLink callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterLabelActivateCurrentLink :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelActivateCurrentLinkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateLink</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> label #activateLink callback
--   </pre>
onLabelActivateLink :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelActivateLinkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateLink</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> label #activateLink callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterLabelActivateLink :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelActivateLinkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>copyClipboard</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> label #copyClipboard callback
--   </pre>
onLabelCopyClipboard :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelCopyClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>copyClipboard</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> label #copyClipboard callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterLabelCopyClipboard :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelCopyClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> label #moveCursor callback
--   </pre>
onLabelMoveCursor :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> label #moveCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterLabelMoveCursor :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>populatePopup</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> label #populatePopup callback
--   </pre>
onLabelPopulatePopup :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelPopulatePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>populatePopup</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> label #populatePopup callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterLabelPopulatePopup :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelPopulatePopupCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>angle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #angle
--   </pre>
getLabelAngle :: (MonadIO m, IsLabel o) => o -> m Double

-- | Set the value of the “<tt>angle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #angle <a>:=</a> value ]
--   </pre>
setLabelAngle :: (MonadIO m, IsLabel o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>angle</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLabelAngle :: (IsLabel o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #attributes
--   </pre>
getLabelAttributes :: (MonadIO m, IsLabel o) => o -> m (Maybe AttrList)

-- | Set the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #attributes <a>:=</a> value ]
--   </pre>
setLabelAttributes :: (MonadIO m, IsLabel o) => o -> AttrList -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>attributes</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLabelAttributes :: (IsLabel o, MonadIO m) => AttrList -> m (GValueConstruct o)

-- | Set the value of the “<tt>attributes</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #attributes
--   </pre>
clearLabelAttributes :: (MonadIO m, IsLabel o) => o -> m ()

-- | Get the value of the “<tt>cursor-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #cursorPosition
--   </pre>
getLabelCursorPosition :: (MonadIO m, IsLabel o) => o -> m Int32

-- | Get the value of the “<tt>ellipsize</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #ellipsize
--   </pre>
getLabelEllipsize :: (MonadIO m, IsLabel o) => o -> m EllipsizeMode

-- | Set the value of the “<tt>ellipsize</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #ellipsize <a>:=</a> value ]
--   </pre>
setLabelEllipsize :: (MonadIO m, IsLabel o) => o -> EllipsizeMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ellipsize</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLabelEllipsize :: (IsLabel o, MonadIO m) => EllipsizeMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>justify</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #justify
--   </pre>
getLabelJustify :: (MonadIO m, IsLabel o) => o -> m Justification

-- | Set the value of the “<tt>justify</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #justify <a>:=</a> value ]
--   </pre>
setLabelJustify :: (MonadIO m, IsLabel o) => o -> Justification -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>justify</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLabelJustify :: (IsLabel o, MonadIO m) => Justification -> m (GValueConstruct o)

-- | Get the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #label
--   </pre>
getLabelLabel :: (MonadIO m, IsLabel o) => o -> m Text

-- | Set the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #label <a>:=</a> value ]
--   </pre>
setLabelLabel :: (MonadIO m, IsLabel o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLabelLabel :: (IsLabel o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #lines
--   </pre>
getLabelLines :: (MonadIO m, IsLabel o) => o -> m Int32

-- | Set the value of the “<tt>lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #lines <a>:=</a> value ]
--   </pre>
setLabelLines :: (MonadIO m, IsLabel o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>lines</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLabelLines :: (IsLabel o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #maxWidthChars
--   </pre>
getLabelMaxWidthChars :: (MonadIO m, IsLabel o) => o -> m Int32

-- | Set the value of the “<tt>max-width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #maxWidthChars <a>:=</a> value ]
--   </pre>
setLabelMaxWidthChars :: (MonadIO m, IsLabel o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-width-chars</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructLabelMaxWidthChars :: (IsLabel o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>mnemonic-keyval</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #mnemonicKeyval
--   </pre>
getLabelMnemonicKeyval :: (MonadIO m, IsLabel o) => o -> m Word32

-- | Get the value of the “<tt>mnemonic-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #mnemonicWidget
--   </pre>
getLabelMnemonicWidget :: (MonadIO m, IsLabel o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>mnemonic-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #mnemonicWidget <a>:=</a> value ]
--   </pre>
setLabelMnemonicWidget :: (MonadIO m, IsLabel o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>mnemonic-widget</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructLabelMnemonicWidget :: (IsLabel o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>mnemonic-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #mnemonicWidget
--   </pre>
clearLabelMnemonicWidget :: (MonadIO m, IsLabel o) => o -> m ()

-- | Set the value of the “<tt>pattern</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #pattern <a>:=</a> value ]
--   </pre>
setLabelPattern :: (MonadIO m, IsLabel o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pattern</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLabelPattern :: (IsLabel o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>selectable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #selectable
--   </pre>
getLabelSelectable :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “<tt>selectable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #selectable <a>:=</a> value ]
--   </pre>
setLabelSelectable :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>selectable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLabelSelectable :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>selection-bound</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #selectionBound
--   </pre>
getLabelSelectionBound :: (MonadIO m, IsLabel o) => o -> m Int32

-- | Get the value of the “<tt>single-line-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #singleLineMode
--   </pre>
getLabelSingleLineMode :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “<tt>single-line-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #singleLineMode <a>:=</a> value ]
--   </pre>
setLabelSingleLineMode :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>single-line-mode</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructLabelSingleLineMode :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>track-visited-links</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #trackVisitedLinks
--   </pre>
getLabelTrackVisitedLinks :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “<tt>track-visited-links</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #trackVisitedLinks <a>:=</a> value ]
--   </pre>
setLabelTrackVisitedLinks :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>track-visited-links</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructLabelTrackVisitedLinks :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #useMarkup
--   </pre>
getLabelUseMarkup :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “<tt>use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #useMarkup <a>:=</a> value ]
--   </pre>
setLabelUseMarkup :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-markup</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLabelUseMarkup :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #useUnderline
--   </pre>
getLabelUseUnderline :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #useUnderline <a>:=</a> value ]
--   </pre>
setLabelUseUnderline :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-underline</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructLabelUseUnderline :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #widthChars
--   </pre>
getLabelWidthChars :: (MonadIO m, IsLabel o) => o -> m Int32

-- | Set the value of the “<tt>width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #widthChars <a>:=</a> value ]
--   </pre>
setLabelWidthChars :: (MonadIO m, IsLabel o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>width-chars</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructLabelWidthChars :: (IsLabel o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #wrap
--   </pre>
getLabelWrap :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “<tt>wrap</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #wrap <a>:=</a> value ]
--   </pre>
setLabelWrap :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLabelWrap :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #wrapMode
--   </pre>
getLabelWrapMode :: (MonadIO m, IsLabel o) => o -> m WrapMode

-- | Set the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #wrapMode <a>:=</a> value ]
--   </pre>
setLabelWrapMode :: (MonadIO m, IsLabel o) => o -> WrapMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap-mode</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLabelWrapMode :: (IsLabel o, MonadIO m) => WrapMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #xalign
--   </pre>
getLabelXalign :: (MonadIO m, IsLabel o) => o -> m Float

-- | Set the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #xalign <a>:=</a> value ]
--   </pre>
setLabelXalign :: (MonadIO m, IsLabel o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>xalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLabelXalign :: (IsLabel o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #yalign
--   </pre>
getLabelYalign :: (MonadIO m, IsLabel o) => o -> m Float

-- | Set the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #yalign <a>:=</a> value ]
--   </pre>
setLabelYalign :: (MonadIO m, IsLabel o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>yalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLabelYalign :: (IsLabel o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Creates a new label with the given text inside it. You can pass
--   <a>Nothing</a> to get an empty label widget.
labelNew :: (HasCallStack, MonadIO m) => Maybe Text -> m Label

-- | Gets the angle of rotation for the label. See <a>labelSetAngle</a>.
--   
--   <i>Since: 2.6</i>
labelGetAngle :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Double

-- | Gets the attribute list that was set on the label using
--   <a>labelSetAttributes</a>, if any. This function does not reflect
--   attributes that come from the labels markup (see
--   <a>labelSetMarkup</a>). If you want to get the effective attributes
--   for the label, use pango_layout_get_attribute (gtk_label_get_layout
--   (label)).
labelGetAttributes :: (HasCallStack, MonadIO m, IsLabel a) => a -> m (Maybe AttrList)

-- | Returns the URI for the currently active link in the label. The active
--   link is the one under the mouse pointer or, in a selectable label, the
--   link in which the text cursor is currently positioned.
--   
--   This function is intended for use in a <a>Label::activateLink</a>
--   handler or for use in a <a>Widget::queryTooltip</a> handler.
--   
--   <i>Since: 2.18</i>
labelGetCurrentUri :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Text

-- | Returns the ellipsizing position of the label. See
--   <a>labelSetEllipsize</a>.
--   
--   <i>Since: 2.6</i>
labelGetEllipsize :: (HasCallStack, MonadIO m, IsLabel a) => a -> m EllipsizeMode

-- | Returns the justification of the label. See <a>labelSetJustify</a>.
labelGetJustify :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Justification

-- | Fetches the text from a label widget including any embedded underlines
--   indicating mnemonics and Pango markup. (See <a>labelGetText</a>).
labelGetLabel :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Text

-- | Gets the <a>Layout</a> used to display the label. The layout is useful
--   to e.g. convert text positions to pixel positions, in combination with
--   <a>labelGetLayoutOffsets</a>. The returned layout is owned by the
--   <i><tt>label</tt></i> so need not be freed by the caller. The
--   <i><tt>label</tt></i> is free to recreate its layout at any time, so
--   it should be considered read-only.
labelGetLayout :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Layout

-- | Obtains the coordinates where the label will draw the <a>Layout</a>
--   representing the text in the label; useful to convert mouse events
--   into coordinates inside the <a>Layout</a>, e.g. to take some action if
--   some part of the label is clicked. Of course you will need to create a
--   <a>EventBox</a> to receive the events, and pack the label inside it,
--   since labels are windowless (they return <a>False</a> from
--   <a>widgetGetHasWindow</a>). Remember when using the <a>Layout</a>
--   functions you need to convert to and from pixels using
--   <tt><i>PANGO_PIXELS()</i></tt> or <a>SCALE</a>.
labelGetLayoutOffsets :: (HasCallStack, MonadIO m, IsLabel a) => a -> m (Int32, Int32)

-- | Returns whether lines in the label are automatically wrapped. See
--   <a>labelSetLineWrap</a>.
labelGetLineWrap :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Bool

-- | Returns line wrap mode used by the label. See
--   <a>labelSetLineWrapMode</a>.
--   
--   <i>Since: 2.10</i>
labelGetLineWrapMode :: (HasCallStack, MonadIO m, IsLabel a) => a -> m WrapMode

-- | Gets the number of lines to which an ellipsized, wrapping label should
--   be limited. See <a>labelSetLines</a>.
--   
--   <i>Since: 3.10</i>
labelGetLines :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Int32

-- | Retrieves the desired maximum width of <i><tt>label</tt></i>, in
--   characters. See <a>labelSetWidthChars</a>.
--   
--   <i>Since: 2.6</i>
labelGetMaxWidthChars :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Int32

-- | If the label has been set so that it has an mnemonic key this function
--   returns the keyval used for the mnemonic accelerator. If there is no
--   mnemonic set up it returns <a>KEY_VoidSymbol</a>.
labelGetMnemonicKeyval :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Word32

-- | Retrieves the target of the mnemonic (keyboard shortcut) of this
--   label. See <a>labelSetMnemonicWidget</a>.
labelGetMnemonicWidget :: (HasCallStack, MonadIO m, IsLabel a) => a -> m (Maybe Widget)

-- | Gets the value set by <a>labelSetSelectable</a>.
labelGetSelectable :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Bool

-- | Gets the selected range of characters in the label, returning
--   <a>True</a> if there’s a selection.
labelGetSelectionBounds :: (HasCallStack, MonadIO m, IsLabel a) => a -> m (Bool, Int32, Int32)

-- | Returns whether the label is in single line mode.
--   
--   <i>Since: 2.6</i>
labelGetSingleLineMode :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Bool

-- | Fetches the text from a label widget, as displayed on the screen. This
--   does not include any embedded underlines indicating mnemonics or Pango
--   markup. (See <a>labelGetLabel</a>)
labelGetText :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Text

-- | Returns whether the label is currently keeping track of clicked links.
--   
--   <i>Since: 2.18</i>
labelGetTrackVisitedLinks :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Bool

-- | Returns whether the label’s text is interpreted as marked up with the
--   [Pango text markup language][PangoMarkupFormat]. See
--   gtk_label_set_use_markup ().
labelGetUseMarkup :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Bool

-- | Returns whether an embedded underline in the label indicates a
--   mnemonic. See <a>labelSetUseUnderline</a>.
labelGetUseUnderline :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Bool

-- | Retrieves the desired width of <i><tt>label</tt></i>, in characters.
--   See <a>labelSetWidthChars</a>.
--   
--   <i>Since: 2.6</i>
labelGetWidthChars :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Int32

-- | Gets the <a>Label:xalign</a> property for <i><tt>label</tt></i>.
--   
--   <i>Since: 3.16</i>
labelGetXalign :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Float

-- | Gets the <a>Label:yalign</a> property for <i><tt>label</tt></i>.
--   
--   <i>Since: 3.16</i>
labelGetYalign :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Float

-- | Selects a range of characters in the label, if the label is
--   selectable. See <a>labelSetSelectable</a>. If the label is not
--   selectable, this function has no effect. If
--   <i><tt>startOffset</tt></i> or <i><tt>endOffset</tt></i> are -1, then
--   the end of the label will be substituted.
labelSelectRegion :: (HasCallStack, MonadIO m, IsLabel a) => a -> Int32 -> Int32 -> m ()

-- | Sets the angle of rotation for the label. An angle of 90 reads from
--   from bottom to top, an angle of 270, from top to bottom. The angle
--   setting for the label is ignored if the label is selectable, wrapped,
--   or ellipsized.
--   
--   <i>Since: 2.6</i>
labelSetAngle :: (HasCallStack, MonadIO m, IsLabel a) => a -> Double -> m ()

-- | Sets a <a>AttrList</a>; the attributes in the list are applied to the
--   label text.
--   
--   The attributes set with this function will be applied and merged with
--   any other attributes previously effected by way of the
--   <a>Label:useUnderline</a> or <a>Label:useMarkup</a> properties. While
--   it is not recommended to mix markup strings with manually set
--   attributes, if you must; know that the attributes will be applied to
--   the label after the markup string is parsed.
labelSetAttributes :: (HasCallStack, MonadIO m, IsLabel a) => a -> Maybe AttrList -> m ()

-- | Sets the mode used to ellipsize (add an ellipsis: "...") to the text
--   if there is not enough space to render the entire string.
--   
--   <i>Since: 2.6</i>
labelSetEllipsize :: (HasCallStack, MonadIO m, IsLabel a) => a -> EllipsizeMode -> m ()

-- | Sets the alignment of the lines in the text of the label relative to
--   each other. <a>JustificationLeft</a> is the default value when the
--   widget is first created with <a>labelNew</a>. If you instead want to
--   set the alignment of the label as a whole, use <a>widgetSetHalign</a>
--   instead. <a>labelSetJustify</a> has no effect on labels containing
--   only a single line.
labelSetJustify :: (HasCallStack, MonadIO m, IsLabel a) => a -> Justification -> m ()

-- | Sets the text of the label. The label is interpreted as including
--   embedded underlines and/or Pango markup depending on the values of the
--   <a>Label:useUnderline</a> and <a>Label:useMarkup</a> properties.
labelSetLabel :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Toggles line wrapping within the <a>Label</a> widget. <a>True</a>
--   makes it break lines if text exceeds the widget’s size. <a>False</a>
--   lets the text get cut off by the edge of the widget if it exceeds the
--   widget size.
--   
--   Note that setting line wrapping to <a>True</a> does not make the label
--   wrap at its parent container’s width, because GTK+ widgets
--   conceptually can’t make their requisition depend on the parent
--   container’s size. For a label that wraps at a specific position, set
--   the label’s width using <a>widgetSetSizeRequest</a>.
labelSetLineWrap :: (HasCallStack, MonadIO m, IsLabel a) => a -> Bool -> m ()

-- | If line wrapping is on (see <a>labelSetLineWrap</a>) this controls how
--   the line wrapping is done. The default is <a>WrapModeWord</a> which
--   means wrap on word boundaries.
--   
--   <i>Since: 2.10</i>
labelSetLineWrapMode :: (HasCallStack, MonadIO m, IsLabel a) => a -> WrapMode -> m ()

-- | Sets the number of lines to which an ellipsized, wrapping label should
--   be limited. This has no effect if the label is not wrapping or
--   ellipsized. Set this to -1 if you don’t want to limit the number of
--   lines.
--   
--   <i>Since: 3.10</i>
labelSetLines :: (HasCallStack, MonadIO m, IsLabel a) => a -> Int32 -> m ()

-- | Parses <i><tt>str</tt></i> which is marked up with the [Pango text
--   markup language][PangoMarkupFormat], setting the label’s text and
--   attribute list based on the parse results. If characters in
--   <i><tt>str</tt></i> are preceded by an underscore, they are underlined
--   indicating that they represent a keyboard accelerator called a
--   mnemonic.
--   
--   The mnemonic key can be used to activate another widget, chosen
--   automatically, or explicitly using <a>labelSetMnemonicWidget</a>.
labelSetMarkupWithMnemonic :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Sets the desired maximum width in characters of <i><tt>label</tt></i>
--   to <i><tt>nChars</tt></i>.
--   
--   <i>Since: 2.6</i>
labelSetMaxWidthChars :: (HasCallStack, MonadIO m, IsLabel a) => a -> Int32 -> m ()

-- | The pattern of underlines you want under the existing text within the
--   <a>Label</a> widget. For example if the current text of the label says
--   “FooBarBaz” passing a pattern of “<b>_ </b>_” will underline “Foo” and
--   “Baz” but not “Bar”.
labelSetPattern :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Selectable labels allow the user to select text from the label, for
--   copy-and-paste.
labelSetSelectable :: (HasCallStack, MonadIO m, IsLabel a) => a -> Bool -> m ()

-- | Sets whether the label is in single line mode.
--   
--   <i>Since: 2.6</i>
labelSetSingleLineMode :: (HasCallStack, MonadIO m, IsLabel a) => a -> Bool -> m ()

-- | Sets the text within the <a>Label</a> widget. It overwrites any text
--   that was there before.
--   
--   This function will clear any previously set mnemonic accelerators, and
--   set the <a>Label:useUnderline</a> property to <a>False</a> as a side
--   effect.
--   
--   This function will set the <a>Label:useMarkup</a> property to
--   <a>False</a> as a side effect.
--   
--   See also: <a>labelSetMarkup</a>
labelSetText :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Sets the label’s text from the string <i><tt>str</tt></i>. If
--   characters in <i><tt>str</tt></i> are preceded by an underscore, they
--   are underlined indicating that they represent a keyboard accelerator
--   called a mnemonic. The mnemonic key can be used to activate another
--   widget, chosen automatically, or explicitly using
--   <a>labelSetMnemonicWidget</a>.
labelSetTextWithMnemonic :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Sets whether the label should keep track of clicked links (and use a
--   different color for them).
--   
--   <i>Since: 2.18</i>
labelSetTrackVisitedLinks :: (HasCallStack, MonadIO m, IsLabel a) => a -> Bool -> m ()

-- | Sets whether the text of the label contains markup in [Pango’s text
--   markup language][PangoMarkupFormat]. See <a>labelSetMarkup</a>.
labelSetUseMarkup :: (HasCallStack, MonadIO m, IsLabel a) => a -> Bool -> m ()

-- | If true, an underline in the text indicates the next character should
--   be used for the mnemonic accelerator key.
labelSetUseUnderline :: (HasCallStack, MonadIO m, IsLabel a) => a -> Bool -> m ()

-- | Sets the desired width in characters of <i><tt>label</tt></i> to
--   <i><tt>nChars</tt></i>.
--   
--   <i>Since: 2.6</i>
labelSetWidthChars :: (HasCallStack, MonadIO m, IsLabel a) => a -> Int32 -> m ()

-- | Sets the <a>Label:xalign</a> property for <i><tt>label</tt></i>.
--   
--   <i>Since: 3.16</i>
labelSetXalign :: (HasCallStack, MonadIO m, IsLabel a) => a -> Float -> m ()

-- | Sets the <a>Label:yalign</a> property for <i><tt>label</tt></i>.
--   
--   <i>Since: 3.16</i>
labelSetYalign :: (HasCallStack, MonadIO m, IsLabel a) => a -> Float -> m ()

-- | Cast to <a>ImageMenuItem</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toImageMenuItem :: (MonadIO m, IsImageMenuItem o) => o -> m ImageMenuItem

-- | Set the value of the “<tt>accel-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> imageMenuItem [ #accelGroup <a>:=</a> value ]
--   </pre>
setImageMenuItemAccelGroup :: (MonadIO m, IsImageMenuItem o, IsAccelGroup a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-group</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructImageMenuItemAccelGroup :: (IsImageMenuItem o, MonadIO m, IsAccelGroup a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>always-show-image</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> imageMenuItem #alwaysShowImage
--   </pre>
getImageMenuItemAlwaysShowImage :: (MonadIO m, IsImageMenuItem o) => o -> m Bool

-- | Set the value of the “<tt>always-show-image</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> imageMenuItem [ #alwaysShowImage <a>:=</a> value ]
--   </pre>
setImageMenuItemAlwaysShowImage :: (MonadIO m, IsImageMenuItem o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>always-show-image</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructImageMenuItemAlwaysShowImage :: (IsImageMenuItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>image</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> imageMenuItem #image
--   </pre>
getImageMenuItemImage :: (MonadIO m, IsImageMenuItem o) => o -> m Widget

-- | Set the value of the “<tt>image</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> imageMenuItem [ #image <a>:=</a> value ]
--   </pre>
setImageMenuItemImage :: (MonadIO m, IsImageMenuItem o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>image</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructImageMenuItemImage :: (IsImageMenuItem o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>image</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #image
--   </pre>
clearImageMenuItemImage :: (MonadIO m, IsImageMenuItem o) => o -> m ()

-- | Get the value of the “<tt>use-stock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> imageMenuItem #useStock
--   </pre>
getImageMenuItemUseStock :: (MonadIO m, IsImageMenuItem o) => o -> m Bool

-- | Set the value of the “<tt>use-stock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> imageMenuItem [ #useStock <a>:=</a> value ]
--   </pre>
setImageMenuItemUseStock :: (MonadIO m, IsImageMenuItem o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-stock</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructImageMenuItemUseStock :: (IsImageMenuItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>ImageMenuItem</a> with an empty label.
imageMenuItemNew :: (HasCallStack, MonadIO m) => m ImageMenuItem

-- | Creates a new <a>ImageMenuItem</a> containing the image and text from
--   a stock item. Some stock ids have preprocessor macros like
--   <a>STOCK_OK</a> and <a>STOCK_APPLY</a>.
--   
--   If you want this menu item to have changeable accelerators, then pass
--   in <a>Nothing</a> for accel_group. Next call
--   <a>menuItemSetAccelPath</a> with an appropriate path for the menu
--   item, use <a>stockLookup</a> to look up the standard accelerator for
--   the stock item, and if one is found, call <a>accelMapAddEntry</a> to
--   register it.
imageMenuItemNewFromStock :: (HasCallStack, MonadIO m, IsAccelGroup a) => Text -> Maybe a -> m ImageMenuItem

-- | Creates a new <a>ImageMenuItem</a> containing a label.
imageMenuItemNewWithLabel :: (HasCallStack, MonadIO m) => Text -> m ImageMenuItem

-- | Creates a new <a>ImageMenuItem</a> containing a label. The label will
--   be created using <a>labelNewWithMnemonic</a>, so underscores in
--   <i><tt>label</tt></i> indicate the mnemonic for the menu item.
imageMenuItemNewWithMnemonic :: (HasCallStack, MonadIO m) => Text -> m ImageMenuItem

-- | Returns whether the menu item will ignore the
--   <a>Settings:gtkMenuImages</a> setting and always show the image, if
--   available.
--   
--   <i>Since: 2.16</i>
imageMenuItemGetAlwaysShowImage :: (HasCallStack, MonadIO m, IsImageMenuItem a) => a -> m Bool

-- | Gets the widget that is currently set as the image of
--   <i><tt>imageMenuItem</tt></i>. See <a>imageMenuItemSetImage</a>.
imageMenuItemGetImage :: (HasCallStack, MonadIO m, IsImageMenuItem a) => a -> m Widget

-- | Checks whether the label set in the menuitem is used as a stock id to
--   select the stock item for the item.
--   
--   <i>Since: 2.16</i>
imageMenuItemGetUseStock :: (HasCallStack, MonadIO m, IsImageMenuItem a) => a -> m Bool

-- | Specifies an <i><tt>accelGroup</tt></i> to add the menu items
--   accelerator to (this only applies to stock items so a stock item must
--   already be set, make sure to call <a>imageMenuItemSetUseStock</a> and
--   <a>menuItemSetLabel</a> with a valid stock item first).
--   
--   If you want this menu item to have changeable accelerators then you
--   shouldnt need this (see <a>imageMenuItemNewFromStock</a>).
--   
--   <i>Since: 2.16</i>
imageMenuItemSetAccelGroup :: (HasCallStack, MonadIO m, IsImageMenuItem a, IsAccelGroup b) => a -> b -> m ()

-- | If <a>True</a>, the menu item will ignore the
--   <a>Settings:gtkMenuImages</a> setting and always show the image, if
--   available.
--   
--   Use this property if the menuitem would be useless or hard to use
--   without the image.
--   
--   <i>Since: 2.16</i>
imageMenuItemSetAlwaysShowImage :: (HasCallStack, MonadIO m, IsImageMenuItem a) => a -> Bool -> m ()

-- | Sets the image of <i><tt>imageMenuItem</tt></i> to the given widget.
--   Note that it depends on the show-menu-images setting whether the image
--   will be displayed or not.
imageMenuItemSetImage :: (HasCallStack, MonadIO m, IsImageMenuItem a, IsWidget b) => a -> Maybe b -> m ()

-- | If <a>True</a>, the label set in the menuitem is used as a stock id to
--   select the stock item for the item.
--   
--   <i>Since: 2.16</i>
imageMenuItemSetUseStock :: (HasCallStack, MonadIO m, IsImageMenuItem a) => a -> Bool -> m ()

-- | Cast to <a>IMMulticontext</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toIMMulticontext :: (MonadIO m, IsIMMulticontext o) => o -> m IMMulticontext

-- | Creates a new <a>IMMulticontext</a>.
iMMulticontextNew :: (HasCallStack, MonadIO m) => m IMMulticontext

-- | Add menuitems for various available input methods to a menu; the
--   menuitems, when selected, will switch the input method for the context
--   and the global default input method.
iMMulticontextAppendMenuitems :: (HasCallStack, MonadIO m, IsIMMulticontext a, IsMenuShell b) => a -> b -> m ()

-- | Gets the id of the currently active slave of the
--   <i><tt>context</tt></i>.
--   
--   <i>Since: 2.16</i>
iMMulticontextGetContextId :: (HasCallStack, MonadIO m, IsIMMulticontext a) => a -> m Text

-- | Sets the context id for <i><tt>context</tt></i>.
--   
--   This causes the currently active slave of <i><tt>context</tt></i> to
--   be replaced by the slave corresponding to the new context id.
--   
--   <i>Since: 2.16</i>
iMMulticontextSetContextId :: (HasCallStack, MonadIO m, IsIMMulticontext a) => a -> Text -> m ()

-- | Cast to <a>CheckMenuItem</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCheckMenuItem :: (MonadIO m, IsCheckMenuItem o) => o -> m CheckMenuItem

-- | Connect a signal handler for the <a>toggled</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> checkMenuItem #toggled callback
--   </pre>
onCheckMenuItemToggled :: (IsCheckMenuItem a, MonadIO m) => a -> ((?self :: a) => CheckMenuItemToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggled</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> checkMenuItem #toggled callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCheckMenuItemToggled :: (IsCheckMenuItem a, MonadIO m) => a -> ((?self :: a) => CheckMenuItemToggledCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkMenuItem #active
--   </pre>
getCheckMenuItemActive :: (MonadIO m, IsCheckMenuItem o) => o -> m Bool

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkMenuItem [ #active <a>:=</a> value ]
--   </pre>
setCheckMenuItemActive :: (MonadIO m, IsCheckMenuItem o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCheckMenuItemActive :: (IsCheckMenuItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>draw-as-radio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkMenuItem #drawAsRadio
--   </pre>
getCheckMenuItemDrawAsRadio :: (MonadIO m, IsCheckMenuItem o) => o -> m Bool

-- | Set the value of the “<tt>draw-as-radio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkMenuItem [ #drawAsRadio <a>:=</a> value ]
--   </pre>
setCheckMenuItemDrawAsRadio :: (MonadIO m, IsCheckMenuItem o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>draw-as-radio</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCheckMenuItemDrawAsRadio :: (IsCheckMenuItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>inconsistent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkMenuItem #inconsistent
--   </pre>
getCheckMenuItemInconsistent :: (MonadIO m, IsCheckMenuItem o) => o -> m Bool

-- | Set the value of the “<tt>inconsistent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkMenuItem [ #inconsistent <a>:=</a> value ]
--   </pre>
setCheckMenuItemInconsistent :: (MonadIO m, IsCheckMenuItem o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inconsistent</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCheckMenuItemInconsistent :: (IsCheckMenuItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>CheckMenuItem</a>.
checkMenuItemNew :: (HasCallStack, MonadIO m) => m CheckMenuItem

-- | Creates a new <a>CheckMenuItem</a> with a label.
checkMenuItemNewWithLabel :: (HasCallStack, MonadIO m) => Text -> m CheckMenuItem

-- | Creates a new <a>CheckMenuItem</a> containing a label. The label will
--   be created using <a>labelNewWithMnemonic</a>, so underscores in
--   <i><tt>label</tt></i> indicate the mnemonic for the menu item.
checkMenuItemNewWithMnemonic :: (HasCallStack, MonadIO m) => Text -> m CheckMenuItem

-- | Returns whether the check menu item is active. See
--   gtk_check_menu_item_set_active ().
checkMenuItemGetActive :: (HasCallStack, MonadIO m, IsCheckMenuItem a) => a -> m Bool

-- | Returns whether <i><tt>checkMenuItem</tt></i> looks like a
--   <a>RadioMenuItem</a>
--   
--   <i>Since: 2.4</i>
checkMenuItemGetDrawAsRadio :: (HasCallStack, MonadIO m, IsCheckMenuItem a) => a -> m Bool

-- | Retrieves the value set by <a>checkMenuItemSetInconsistent</a>.
checkMenuItemGetInconsistent :: (HasCallStack, MonadIO m, IsCheckMenuItem a) => a -> m Bool

-- | Sets the active state of the menu item’s check box.
checkMenuItemSetActive :: (HasCallStack, MonadIO m, IsCheckMenuItem a) => a -> Bool -> m ()

-- | Sets whether <i><tt>checkMenuItem</tt></i> is drawn like a
--   <a>RadioMenuItem</a>
--   
--   <i>Since: 2.4</i>
checkMenuItemSetDrawAsRadio :: (HasCallStack, MonadIO m, IsCheckMenuItem a) => a -> Bool -> m ()

-- | If the user has selected a range of elements (such as some text or
--   spreadsheet cells) that are affected by a boolean setting, and the
--   current values in that range are inconsistent, you may want to display
--   the check in an “in between” state. This function turns on “in
--   between” display. Normally you would turn off the inconsistent state
--   again if the user explicitly selects a setting. This has to be done
--   manually, <a>checkMenuItemSetInconsistent</a> only affects visual
--   appearance, it doesn’t affect the semantics of the widget.
checkMenuItemSetInconsistent :: (HasCallStack, MonadIO m, IsCheckMenuItem a) => a -> Bool -> m ()

-- | Emits the <a>CheckMenuItem::toggled</a> signal.
checkMenuItemToggled :: (HasCallStack, MonadIO m, IsCheckMenuItem a) => a -> m ()

-- | Cast to <a>RadioMenuItem</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toRadioMenuItem :: (MonadIO m, IsRadioMenuItem o) => o -> m RadioMenuItem

-- | Connect a signal handler for the <a>groupChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> radioMenuItem #groupChanged callback
--   </pre>
onRadioMenuItemGroupChanged :: (IsRadioMenuItem a, MonadIO m) => a -> ((?self :: a) => RadioMenuItemGroupChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>groupChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> radioMenuItem #groupChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterRadioMenuItemGroupChanged :: (IsRadioMenuItem a, MonadIO m) => a -> ((?self :: a) => RadioMenuItemGroupChangedCallback) -> m SignalHandlerId

-- | Set the value of the “<tt>group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> radioMenuItem [ #group <a>:=</a> value ]
--   </pre>
setRadioMenuItemGroup :: (MonadIO m, IsRadioMenuItem o, IsRadioMenuItem a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>group</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructRadioMenuItemGroup :: (IsRadioMenuItem o, MonadIO m, IsRadioMenuItem a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>group</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #group
--   </pre>
clearRadioMenuItemGroup :: (MonadIO m, IsRadioMenuItem o) => o -> m ()

-- | Creates a new <a>RadioMenuItem</a>.
radioMenuItemNew :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => [a] -> m RadioMenuItem

-- | Creates a new <a>RadioMenuItem</a> adding it to the same group as
--   <i><tt>group</tt></i>.
--   
--   <i>Since: 2.4</i>
radioMenuItemNewFromWidget :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => Maybe a -> m RadioMenuItem

-- | Creates a new <a>RadioMenuItem</a> whose child is a simple
--   <a>Label</a>.
radioMenuItemNewWithLabel :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => [a] -> Text -> m RadioMenuItem

-- | Creates a new GtkRadioMenuItem whose child is a simple GtkLabel. The
--   new <a>RadioMenuItem</a> is added to the same group as
--   <i><tt>group</tt></i>.
--   
--   <i>Since: 2.4</i>
radioMenuItemNewWithLabelFromWidget :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => Maybe a -> Maybe Text -> m RadioMenuItem

-- | Creates a new <a>RadioMenuItem</a> containing a label. The label will
--   be created using <a>labelNewWithMnemonic</a>, so underscores in
--   <i><tt>label</tt></i> indicate the mnemonic for the menu item.
radioMenuItemNewWithMnemonic :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => [a] -> Text -> m RadioMenuItem

-- | Creates a new GtkRadioMenuItem containing a label. The label will be
--   created using <a>labelNewWithMnemonic</a>, so underscores in label
--   indicate the mnemonic for the menu item.
--   
--   The new <a>RadioMenuItem</a> is added to the same group as
--   <i><tt>group</tt></i>.
--   
--   <i>Since: 2.4</i>
radioMenuItemNewWithMnemonicFromWidget :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => Maybe a -> Maybe Text -> m RadioMenuItem

-- | Returns the group to which the radio menu item belongs, as a
--   <a>List</a> of <a>RadioMenuItem</a>. The list belongs to GTK+ and
--   should not be freed.
radioMenuItemGetGroup :: (HasCallStack, MonadIO m, IsRadioMenuItem a) => a -> m [RadioMenuItem]

-- | Joins a <a>RadioMenuItem</a> object to the group of another
--   <a>RadioMenuItem</a> object.
--   
--   This function should be used by language bindings to avoid the memory
--   manangement of the opaque <a>SList</a> of <a>radioMenuItemGetGroup</a>
--   and <a>radioMenuItemSetGroup</a>.
--   
--   A common way to set up a group of <a>RadioMenuItem</a> instances is:
--   
--   <pre>
--   GtkRadioMenuItem *last_item = NULL;
--   
--   while ( ...more items to add... )
--     {
--       GtkRadioMenuItem *radio_item;
--   
--       radio_item = gtk_radio_menu_item_new (...);
--   
--       gtk_radio_menu_item_join_group (radio_item, last_item);
--       last_item = radio_item;
--     }
--   </pre>
--   
--   <i>Since: 3.18</i>
radioMenuItemJoinGroup :: (HasCallStack, MonadIO m, IsRadioMenuItem a, IsRadioMenuItem b) => a -> Maybe b -> m ()

-- | Sets the group of a radio menu item, or changes it.
radioMenuItemSetGroup :: (HasCallStack, MonadIO m, IsRadioMenuItem a, IsRadioMenuItem b) => a -> [b] -> m ()

-- | Cast to <a>Button</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toButton :: (MonadIO m, IsButton o) => o -> m Button

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> button #activate callback
--   </pre>
onButtonActivate :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> button #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterButtonActivate :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>clicked</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> button #clicked callback
--   </pre>
onButtonClicked :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonClickedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>clicked</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> button #clicked callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterButtonClicked :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonClickedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>enter</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> button #enter callback
--   </pre>
onButtonEnter :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonEnterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>enter</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> button #enter callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterButtonEnter :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonEnterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>leave</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> button #leave callback
--   </pre>
onButtonLeave :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>leave</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> button #leave callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterButtonLeave :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pressed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> button #pressed callback
--   </pre>
onButtonPressed :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pressed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> button #pressed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterButtonPressed :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>released</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> button #released callback
--   </pre>
onButtonReleased :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonReleasedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>released</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> button #released callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterButtonReleased :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonReleasedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>always-show-image</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> button #alwaysShowImage
--   </pre>
getButtonAlwaysShowImage :: (MonadIO m, IsButton o) => o -> m Bool

-- | Set the value of the “<tt>always-show-image</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> button [ #alwaysShowImage <a>:=</a> value ]
--   </pre>
setButtonAlwaysShowImage :: (MonadIO m, IsButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>always-show-image</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructButtonAlwaysShowImage :: (IsButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>image</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> button #image
--   </pre>
getButtonImage :: (MonadIO m, IsButton o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>image</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> button [ #image <a>:=</a> value ]
--   </pre>
setButtonImage :: (MonadIO m, IsButton o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>image</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructButtonImage :: (IsButton o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>image</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #image
--   </pre>
clearButtonImage :: (MonadIO m, IsButton o) => o -> m ()

-- | Get the value of the “<tt>image-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> button #imagePosition
--   </pre>
getButtonImagePosition :: (MonadIO m, IsButton o) => o -> m PositionType

-- | Set the value of the “<tt>image-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> button [ #imagePosition <a>:=</a> value ]
--   </pre>
setButtonImagePosition :: (MonadIO m, IsButton o) => o -> PositionType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>image-position</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructButtonImagePosition :: (IsButton o, MonadIO m) => PositionType -> m (GValueConstruct o)

-- | Get the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> button #label
--   </pre>
getButtonLabel :: (MonadIO m, IsButton o) => o -> m Text

-- | Set the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> button [ #label <a>:=</a> value ]
--   </pre>
setButtonLabel :: (MonadIO m, IsButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructButtonLabel :: (IsButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>relief</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> button #relief
--   </pre>
getButtonRelief :: (MonadIO m, IsButton o) => o -> m ReliefStyle

-- | Set the value of the “<tt>relief</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> button [ #relief <a>:=</a> value ]
--   </pre>
setButtonRelief :: (MonadIO m, IsButton o) => o -> ReliefStyle -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>relief</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructButtonRelief :: (IsButton o, MonadIO m) => ReliefStyle -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-stock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> button #useStock
--   </pre>
getButtonUseStock :: (MonadIO m, IsButton o) => o -> m Bool

-- | Set the value of the “<tt>use-stock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> button [ #useStock <a>:=</a> value ]
--   </pre>
setButtonUseStock :: (MonadIO m, IsButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-stock</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructButtonUseStock :: (IsButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> button #useUnderline
--   </pre>
getButtonUseUnderline :: (MonadIO m, IsButton o) => o -> m Bool

-- | Set the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> button [ #useUnderline <a>:=</a> value ]
--   </pre>
setButtonUseUnderline :: (MonadIO m, IsButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-underline</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructButtonUseUnderline :: (IsButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> button #xalign
--   </pre>
getButtonXalign :: (MonadIO m, IsButton o) => o -> m Float

-- | Set the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> button [ #xalign <a>:=</a> value ]
--   </pre>
setButtonXalign :: (MonadIO m, IsButton o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>xalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructButtonXalign :: (IsButton o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> button #yalign
--   </pre>
getButtonYalign :: (MonadIO m, IsButton o) => o -> m Float

-- | Set the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> button [ #yalign <a>:=</a> value ]
--   </pre>
setButtonYalign :: (MonadIO m, IsButton o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>yalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructButtonYalign :: (IsButton o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Creates a new button containing an icon from the current icon theme.
--   
--   If the icon name isn’t known, a “broken image” icon will be displayed
--   instead. If the current icon theme is changed, the icon will be
--   updated appropriately.
--   
--   This function is a convenience wrapper around <a>buttonNew</a> and
--   <a>buttonSetImage</a>.
--   
--   <i>Since: 3.10</i>
buttonNewFromIconName :: (HasCallStack, MonadIO m) => Maybe Text -> Int32 -> m Button

-- | Creates a new <a>Button</a> containing the image and text from a
--   [stock item][gtkstock]. Some stock ids have preprocessor macros like
--   <a>STOCK_OK</a> and <a>STOCK_APPLY</a>.
--   
--   If <i><tt>stockId</tt></i> is unknown, then it will be treated as a
--   mnemonic label (as for <a>buttonNewWithMnemonic</a>).
buttonNewFromStock :: (HasCallStack, MonadIO m) => Text -> m Button

-- | Creates a <a>Button</a> widget with a <a>Label</a> child containing
--   the given text.
buttonNewWithLabel :: (HasCallStack, MonadIO m) => Text -> m Button

-- | Creates a new <a>Button</a> containing a label. If characters in
--   <i><tt>label</tt></i> are preceded by an underscore, they are
--   underlined. If you need a literal underscore character in a label, use
--   “__” (two underscores). The first underlined character represents a
--   keyboard accelerator called a mnemonic. Pressing Alt and that key
--   activates the button.
buttonNewWithMnemonic :: (HasCallStack, MonadIO m) => Text -> m Button

-- | Emits a <a>Button::clicked</a> signal to the given <a>Button</a>.
buttonClicked :: (HasCallStack, MonadIO m, IsButton a) => a -> m ()

-- | Emits a <a>Button::enter</a> signal to the given <a>Button</a>.
buttonEnter :: (HasCallStack, MonadIO m, IsButton a) => a -> m ()

-- | Gets the alignment of the child in the button.
--   
--   <i>Since: 2.4</i>
buttonGetAlignment :: (HasCallStack, MonadIO m, IsButton a) => a -> m (Float, Float)

-- | Returns whether the button will ignore the
--   <a>Settings:gtkButtonImages</a> setting and always show the image, if
--   available.
--   
--   <i>Since: 3.6</i>
buttonGetAlwaysShowImage :: (HasCallStack, MonadIO m, IsButton a) => a -> m Bool

-- | Returns the button’s event window if it is realized, <a>Nothing</a>
--   otherwise. This function should be rarely needed.
--   
--   <i>Since: 2.22</i>
buttonGetEventWindow :: (HasCallStack, MonadIO m, IsButton a) => a -> m Window

-- | Returns whether the button grabs focus when it is clicked with the
--   mouse. See <a>buttonSetFocusOnClick</a>.
--   
--   <i>Since: 2.4</i>
buttonGetFocusOnClick :: (HasCallStack, MonadIO m, IsButton a) => a -> m Bool

-- | Gets the widget that is currenty set as the image of
--   <i><tt>button</tt></i>. This may have been explicitly set by
--   <a>buttonSetImage</a> or constructed by <a>buttonNewFromStock</a>.
--   
--   <i>Since: 2.6</i>
buttonGetImage :: (HasCallStack, MonadIO m, IsButton a) => a -> m (Maybe Widget)

-- | Gets the position of the image relative to the text inside the button.
--   
--   <i>Since: 2.10</i>
buttonGetImagePosition :: (HasCallStack, MonadIO m, IsButton a) => a -> m PositionType

-- | Fetches the text from the label of the button, as set by
--   <a>buttonSetLabel</a>. If the label text has not been set the return
--   value will be <a>Nothing</a>. This will be the case if you create an
--   empty button with <a>buttonNew</a> to use as a container.
buttonGetLabel :: (HasCallStack, MonadIO m, IsButton a) => a -> m Text

-- | Returns the current relief style of the given <a>Button</a>.
buttonGetRelief :: (HasCallStack, MonadIO m, IsButton a) => a -> m ReliefStyle

-- | Returns whether the button label is a stock item.
buttonGetUseStock :: (HasCallStack, MonadIO m, IsButton a) => a -> m Bool

-- | Returns whether an embedded underline in the button label indicates a
--   mnemonic. See gtk_button_set_use_underline ().
buttonGetUseUnderline :: (HasCallStack, MonadIO m, IsButton a) => a -> m Bool

-- | Emits a <a>Button::leave</a> signal to the given <a>Button</a>.
buttonLeave :: (HasCallStack, MonadIO m, IsButton a) => a -> m ()

-- | Emits a <a>Button::pressed</a> signal to the given <a>Button</a>.
buttonPressed :: (HasCallStack, MonadIO m, IsButton a) => a -> m ()

-- | Emits a <a>Button::released</a> signal to the given <a>Button</a>.
buttonReleased :: (HasCallStack, MonadIO m, IsButton a) => a -> m ()

-- | Sets the alignment of the child. This property has no effect unless
--   the child is a <a>Misc</a> or a <a>Alignment</a>.
--   
--   <i>Since: 2.4</i>
buttonSetAlignment :: (HasCallStack, MonadIO m, IsButton a) => a -> Float -> Float -> m ()

-- | If <a>True</a>, the button will ignore the
--   <a>Settings:gtkButtonImages</a> setting and always show the image, if
--   available.
--   
--   Use this property if the button would be useless or hard to use
--   without the image.
--   
--   <i>Since: 3.6</i>
buttonSetAlwaysShowImage :: (HasCallStack, MonadIO m, IsButton a) => a -> Bool -> m ()

-- | Sets whether the button will grab focus when it is clicked with the
--   mouse. Making mouse clicks not grab focus is useful in places like
--   toolbars where you don’t want the keyboard focus removed from the main
--   area of the application.
--   
--   <i>Since: 2.4</i>
buttonSetFocusOnClick :: (HasCallStack, MonadIO m, IsButton a) => a -> Bool -> m ()

-- | Set the image of <i><tt>button</tt></i> to the given widget. The image
--   will be displayed if the label text is <a>Nothing</a> or if
--   <a>Button:alwaysShowImage</a> is <a>True</a>. You don’t have to call
--   <a>widgetShow</a> on <i><tt>image</tt></i> yourself.
--   
--   <i>Since: 2.6</i>
buttonSetImage :: (HasCallStack, MonadIO m, IsButton a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the position of the image relative to the text inside the button.
--   
--   <i>Since: 2.10</i>
buttonSetImagePosition :: (HasCallStack, MonadIO m, IsButton a) => a -> PositionType -> m ()

-- | Sets the text of the label of the button to <i><tt>str</tt></i>. This
--   text is also used to select the stock item if <a>buttonSetUseStock</a>
--   is used.
--   
--   This will also clear any previously set labels.
buttonSetLabel :: (HasCallStack, MonadIO m, IsButton a) => a -> Text -> m ()

-- | If <a>True</a>, the label set on the button is used as a stock id to
--   select the stock item for the button.
buttonSetUseStock :: (HasCallStack, MonadIO m, IsButton a) => a -> Bool -> m ()

-- | If true, an underline in the text of the button label indicates the
--   next character should be used for the mnemonic accelerator key.
buttonSetUseUnderline :: (HasCallStack, MonadIO m, IsButton a) => a -> Bool -> m ()

-- | Cast to <a>ToggleButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toToggleButton :: (MonadIO m, IsToggleButton o) => o -> m ToggleButton

-- | Connect a signal handler for the <a>toggled</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> toggleButton #toggled callback
--   </pre>
onToggleButtonToggled :: (IsToggleButton a, MonadIO m) => a -> ((?self :: a) => ToggleButtonToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggled</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> toggleButton #toggled callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterToggleButtonToggled :: (IsToggleButton a, MonadIO m) => a -> ((?self :: a) => ToggleButtonToggledCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toggleButton #active
--   </pre>
getToggleButtonActive :: (MonadIO m, IsToggleButton o) => o -> m Bool

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toggleButton [ #active <a>:=</a> value ]
--   </pre>
setToggleButtonActive :: (MonadIO m, IsToggleButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructToggleButtonActive :: (IsToggleButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>draw-indicator</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toggleButton #drawIndicator
--   </pre>
getToggleButtonDrawIndicator :: (MonadIO m, IsToggleButton o) => o -> m Bool

-- | Set the value of the “<tt>draw-indicator</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toggleButton [ #drawIndicator <a>:=</a> value ]
--   </pre>
setToggleButtonDrawIndicator :: (MonadIO m, IsToggleButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>draw-indicator</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructToggleButtonDrawIndicator :: (IsToggleButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>inconsistent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toggleButton #inconsistent
--   </pre>
getToggleButtonInconsistent :: (MonadIO m, IsToggleButton o) => o -> m Bool

-- | Set the value of the “<tt>inconsistent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toggleButton [ #inconsistent <a>:=</a> value ]
--   </pre>
setToggleButtonInconsistent :: (MonadIO m, IsToggleButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inconsistent</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructToggleButtonInconsistent :: (IsToggleButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new toggle button. A widget should be packed into the
--   button, as in <a>buttonNew</a>.
toggleButtonNew :: (HasCallStack, MonadIO m) => m ToggleButton

-- | Creates a new toggle button with a text label.
toggleButtonNewWithLabel :: (HasCallStack, MonadIO m) => Text -> m ToggleButton

-- | Creates a new <a>ToggleButton</a> containing a label. The label will
--   be created using <a>labelNewWithMnemonic</a>, so underscores in
--   <i><tt>label</tt></i> indicate the mnemonic for the button.
toggleButtonNewWithMnemonic :: (HasCallStack, MonadIO m) => Text -> m ToggleButton

-- | Queries a <a>ToggleButton</a> and returns its current state. Returns
--   <a>True</a> if the toggle button is pressed in and <a>False</a> if it
--   is raised.
toggleButtonGetActive :: (HasCallStack, MonadIO m, IsToggleButton a) => a -> m Bool

-- | Gets the value set by <a>toggleButtonSetInconsistent</a>.
toggleButtonGetInconsistent :: (HasCallStack, MonadIO m, IsToggleButton a) => a -> m Bool

-- | Retrieves whether the button is displayed as a separate indicator and
--   label. See <a>toggleButtonSetMode</a>.
toggleButtonGetMode :: (HasCallStack, MonadIO m, IsToggleButton a) => a -> m Bool

-- | Sets the status of the toggle button. Set to <a>True</a> if you want
--   the GtkToggleButton to be “pressed in”, and <a>False</a> to raise it.
--   This action causes the <a>ToggleButton::toggled</a> signal and the
--   <a>Button::clicked</a> signal to be emitted.
toggleButtonSetActive :: (HasCallStack, MonadIO m, IsToggleButton a) => a -> Bool -> m ()

-- | If the user has selected a range of elements (such as some text or
--   spreadsheet cells) that are affected by a toggle button, and the
--   current values in that range are inconsistent, you may want to display
--   the toggle in an “in between” state. This function turns on “in
--   between” display. Normally you would turn off the inconsistent state
--   again if the user toggles the toggle button. This has to be done
--   manually, <a>toggleButtonSetInconsistent</a> only affects visual
--   appearance, it doesn’t affect the semantics of the button.
toggleButtonSetInconsistent :: (HasCallStack, MonadIO m, IsToggleButton a) => a -> Bool -> m ()

-- | Sets whether the button is displayed as a separate indicator and
--   label. You can call this function on a checkbutton or a radiobutton
--   with <i><tt>drawIndicator</tt></i> = <a>False</a> to make the button
--   look like a normal button.
--   
--   This can be used to create linked strip of buttons that work like a
--   <a>StackSwitcher</a>.
--   
--   This function only affects instances of classes like
--   <a>CheckButton</a> and <a>RadioButton</a> that derive from
--   <a>ToggleButton</a>, not instances of <a>ToggleButton</a> itself.
toggleButtonSetMode :: (HasCallStack, MonadIO m, IsToggleButton a) => a -> Bool -> m ()

-- | Emits the <a>ToggleButton::toggled</a> signal on the
--   <a>ToggleButton</a>. There is no good reason for an application ever
--   to call this function.
toggleButtonToggled :: (HasCallStack, MonadIO m, IsToggleButton a) => a -> m ()

-- | Cast to <a>ScaleButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toScaleButton :: (MonadIO m, IsScaleButton o) => o -> m ScaleButton

-- | Connect a signal handler for the <a>popdown</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> scaleButton #popdown callback
--   </pre>
onScaleButtonPopdown :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonPopdownCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popdown</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> scaleButton #popdown callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterScaleButtonPopdown :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonPopdownCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popup</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> scaleButton #popup callback
--   </pre>
onScaleButtonPopup :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonPopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popup</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> scaleButton #popup callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterScaleButtonPopup :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonPopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>valueChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> scaleButton #valueChanged callback
--   </pre>
onScaleButtonValueChanged :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonValueChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>valueChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> scaleButton #valueChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterScaleButtonValueChanged :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonValueChangedCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scaleButton #adjustment
--   </pre>
getScaleButtonAdjustment :: (MonadIO m, IsScaleButton o) => o -> m Adjustment

-- | Set the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scaleButton [ #adjustment <a>:=</a> value ]
--   </pre>
setScaleButtonAdjustment :: (MonadIO m, IsScaleButton o, IsAdjustment a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>adjustment</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructScaleButtonAdjustment :: (IsScaleButton o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>icons</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scaleButton #icons
--   </pre>
getScaleButtonIcons :: (MonadIO m, IsScaleButton o) => o -> m (Maybe [Text])

-- | Set the value of the “<tt>icons</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scaleButton [ #icons <a>:=</a> value ]
--   </pre>
setScaleButtonIcons :: (MonadIO m, IsScaleButton o) => o -> [Text] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icons</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructScaleButtonIcons :: (IsScaleButton o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scaleButton #size
--   </pre>
getScaleButtonSize :: (MonadIO m, IsScaleButton o) => o -> m IconSize

-- | Set the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scaleButton [ #size <a>:=</a> value ]
--   </pre>
setScaleButtonSize :: (MonadIO m, IsScaleButton o) => o -> IconSize -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructScaleButtonSize :: (IsScaleButton o, MonadIO m) => IconSize -> m (GValueConstruct o)

-- | Get the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scaleButton #value
--   </pre>
getScaleButtonValue :: (MonadIO m, IsScaleButton o) => o -> m Double

-- | Set the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scaleButton [ #value <a>:=</a> value ]
--   </pre>
setScaleButtonValue :: (MonadIO m, IsScaleButton o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>value</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructScaleButtonValue :: (IsScaleButton o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Creates a <a>ScaleButton</a>, with a range between <i><tt>min</tt></i>
--   and <i><tt>max</tt></i>, with a stepping of <i><tt>step</tt></i>.
--   
--   <i>Since: 2.12</i>
scaleButtonNew :: (HasCallStack, MonadIO m) => Int32 -> Double -> Double -> Double -> Maybe [Text] -> m ScaleButton

-- | Gets the <a>Adjustment</a> associated with the <a>ScaleButton</a>’s
--   scale. See <a>rangeGetAdjustment</a> for details.
--   
--   <i>Since: 2.12</i>
scaleButtonGetAdjustment :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Adjustment

-- | Retrieves the minus button of the <a>ScaleButton</a>.
--   
--   <i>Since: 2.14</i>
scaleButtonGetMinusButton :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Button

-- | Retrieves the plus button of the <a>ScaleButton</a>.
--   
--   <i>Since: 2.14</i>
scaleButtonGetPlusButton :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Button

-- | Retrieves the popup of the <a>ScaleButton</a>.
--   
--   <i>Since: 2.14</i>
scaleButtonGetPopup :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Widget

-- | Gets the current value of the scale button.
--   
--   <i>Since: 2.12</i>
scaleButtonGetValue :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Double

-- | Sets the <a>Adjustment</a> to be used as a model for the
--   <a>ScaleButton</a>’s scale. See <a>rangeSetAdjustment</a> for details.
--   
--   <i>Since: 2.12</i>
scaleButtonSetAdjustment :: (HasCallStack, MonadIO m, IsScaleButton a, IsAdjustment b) => a -> b -> m ()

-- | Sets the icons to be used by the scale button. For details, see the
--   <a>ScaleButton:icons</a> property.
--   
--   <i>Since: 2.12</i>
scaleButtonSetIcons :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> [Text] -> m ()

-- | Sets the current value of the scale; if the value is outside the
--   minimum or maximum range values, it will be clamped to fit inside
--   them. The scale button emits the <a>ScaleButton::valueChanged</a>
--   signal if the value changes.
--   
--   <i>Since: 2.12</i>
scaleButtonSetValue :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> Double -> m ()

-- | Cast to <a>VolumeButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toVolumeButton :: (MonadIO m, IsVolumeButton o) => o -> m VolumeButton

-- | Get the value of the “<tt>use-symbolic</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> volumeButton #useSymbolic
--   </pre>
getVolumeButtonUseSymbolic :: (MonadIO m, IsVolumeButton o) => o -> m Bool

-- | Set the value of the “<tt>use-symbolic</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> volumeButton [ #useSymbolic <a>:=</a> value ]
--   </pre>
setVolumeButtonUseSymbolic :: (MonadIO m, IsVolumeButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-symbolic</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructVolumeButtonUseSymbolic :: (IsVolumeButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a <a>VolumeButton</a>, with a range between 0.0 and 1.0, with
--   a stepping of 0.02. Volume values can be obtained and modified using
--   the functions from <a>ScaleButton</a>.
--   
--   <i>Since: 2.12</i>
volumeButtonNew :: (HasCallStack, MonadIO m) => m VolumeButton

-- | Cast to <a>ModelButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toModelButton :: (MonadIO m, IsModelButton o) => o -> m ModelButton

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> modelButton #active
--   </pre>
getModelButtonActive :: (MonadIO m, IsModelButton o) => o -> m Bool

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> modelButton [ #active <a>:=</a> value ]
--   </pre>
setModelButtonActive :: (MonadIO m, IsModelButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructModelButtonActive :: (IsModelButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>centered</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> modelButton #centered
--   </pre>
getModelButtonCentered :: (MonadIO m, IsModelButton o) => o -> m Bool

-- | Set the value of the “<tt>centered</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> modelButton [ #centered <a>:=</a> value ]
--   </pre>
setModelButtonCentered :: (MonadIO m, IsModelButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>centered</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructModelButtonCentered :: (IsModelButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> modelButton #icon
--   </pre>
getModelButtonIcon :: (MonadIO m, IsModelButton o) => o -> m (Maybe Icon)

-- | Set the value of the “<tt>icon</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> modelButton [ #icon <a>:=</a> value ]
--   </pre>
setModelButtonIcon :: (MonadIO m, IsModelButton o, IsIcon a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructModelButtonIcon :: (IsModelButton o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>icon</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #icon
--   </pre>
clearModelButtonIcon :: (MonadIO m, IsModelButton o) => o -> m ()

-- | Get the value of the “<tt>iconic</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> modelButton #iconic
--   </pre>
getModelButtonIconic :: (MonadIO m, IsModelButton o) => o -> m Bool

-- | Set the value of the “<tt>iconic</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> modelButton [ #iconic <a>:=</a> value ]
--   </pre>
setModelButtonIconic :: (MonadIO m, IsModelButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>iconic</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructModelButtonIconic :: (IsModelButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> modelButton #inverted
--   </pre>
getModelButtonInverted :: (MonadIO m, IsModelButton o) => o -> m Bool

-- | Set the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> modelButton [ #inverted <a>:=</a> value ]
--   </pre>
setModelButtonInverted :: (MonadIO m, IsModelButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inverted</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructModelButtonInverted :: (IsModelButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>menu-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> modelButton #menuName
--   </pre>
getModelButtonMenuName :: (MonadIO m, IsModelButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>menu-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> modelButton [ #menuName <a>:=</a> value ]
--   </pre>
setModelButtonMenuName :: (MonadIO m, IsModelButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>menu-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructModelButtonMenuName :: (IsModelButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>menu-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #menuName
--   </pre>
clearModelButtonMenuName :: (MonadIO m, IsModelButton o) => o -> m ()

-- | Get the value of the “<tt>role</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> modelButton #role
--   </pre>
getModelButtonRole :: (MonadIO m, IsModelButton o) => o -> m ButtonRole

-- | Set the value of the “<tt>role</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> modelButton [ #role <a>:=</a> value ]
--   </pre>
setModelButtonRole :: (MonadIO m, IsModelButton o) => o -> ButtonRole -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>role</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructModelButtonRole :: (IsModelButton o, MonadIO m) => ButtonRole -> m (GValueConstruct o)

-- | Get the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> modelButton #text
--   </pre>
getModelButtonText :: (MonadIO m, IsModelButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> modelButton [ #text <a>:=</a> value ]
--   </pre>
setModelButtonText :: (MonadIO m, IsModelButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructModelButtonText :: (IsModelButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>text</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #text
--   </pre>
clearModelButtonText :: (MonadIO m, IsModelButton o) => o -> m ()

-- | Get the value of the “<tt>use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> modelButton #useMarkup
--   </pre>
getModelButtonUseMarkup :: (MonadIO m, IsModelButton o) => o -> m Bool

-- | Set the value of the “<tt>use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> modelButton [ #useMarkup <a>:=</a> value ]
--   </pre>
setModelButtonUseMarkup :: (MonadIO m, IsModelButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-markup</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructModelButtonUseMarkup :: (IsModelButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new GtkModelButton.
--   
--   <i>Since: 3.16</i>
modelButtonNew :: (HasCallStack, MonadIO m) => m ModelButton

-- | Cast to <a>MenuButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMenuButton :: (MonadIO m, IsMenuButton o) => o -> m MenuButton

-- | Get the value of the “<tt>align-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #alignWidget
--   </pre>
getMenuButtonAlignWidget :: (MonadIO m, IsMenuButton o) => o -> m (Maybe Container)

-- | Set the value of the “<tt>align-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #alignWidget <a>:=</a> value ]
--   </pre>
setMenuButtonAlignWidget :: (MonadIO m, IsMenuButton o, IsContainer a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>align-widget</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructMenuButtonAlignWidget :: (IsMenuButton o, MonadIO m, IsContainer a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>align-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #alignWidget
--   </pre>
clearMenuButtonAlignWidget :: (MonadIO m, IsMenuButton o) => o -> m ()

-- | Get the value of the “<tt>direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #direction
--   </pre>
getMenuButtonDirection :: (MonadIO m, IsMenuButton o) => o -> m ArrowType

-- | Set the value of the “<tt>direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #direction <a>:=</a> value ]
--   </pre>
setMenuButtonDirection :: (MonadIO m, IsMenuButton o) => o -> ArrowType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>direction</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructMenuButtonDirection :: (IsMenuButton o, MonadIO m) => ArrowType -> m (GValueConstruct o)

-- | Get the value of the “<tt>menu-model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #menuModel
--   </pre>
getMenuButtonMenuModel :: (MonadIO m, IsMenuButton o) => o -> m (Maybe MenuModel)

-- | Set the value of the “<tt>menu-model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #menuModel <a>:=</a> value ]
--   </pre>
setMenuButtonMenuModel :: (MonadIO m, IsMenuButton o, IsMenuModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>menu-model</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructMenuButtonMenuModel :: (IsMenuButton o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>menu-model</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #menuModel
--   </pre>
clearMenuButtonMenuModel :: (MonadIO m, IsMenuButton o) => o -> m ()

-- | Get the value of the “<tt>popover</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #popover
--   </pre>
getMenuButtonPopover :: (MonadIO m, IsMenuButton o) => o -> m (Maybe Popover)

-- | Set the value of the “<tt>popover</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #popover <a>:=</a> value ]
--   </pre>
setMenuButtonPopover :: (MonadIO m, IsMenuButton o, IsPopover a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>popover</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMenuButtonPopover :: (IsMenuButton o, MonadIO m, IsPopover a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>popover</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #popover
--   </pre>
clearMenuButtonPopover :: (MonadIO m, IsMenuButton o) => o -> m ()

-- | Get the value of the “<tt>popup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #popup
--   </pre>
getMenuButtonPopup :: (MonadIO m, IsMenuButton o) => o -> m (Maybe Menu)

-- | Set the value of the “<tt>popup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #popup <a>:=</a> value ]
--   </pre>
setMenuButtonPopup :: (MonadIO m, IsMenuButton o, IsMenu a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>popup</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMenuButtonPopup :: (IsMenuButton o, MonadIO m, IsMenu a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>popup</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #popup
--   </pre>
clearMenuButtonPopup :: (MonadIO m, IsMenuButton o) => o -> m ()

-- | Get the value of the “<tt>use-popover</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #usePopover
--   </pre>
getMenuButtonUsePopover :: (MonadIO m, IsMenuButton o) => o -> m Bool

-- | Set the value of the “<tt>use-popover</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #usePopover <a>:=</a> value ]
--   </pre>
setMenuButtonUsePopover :: (MonadIO m, IsMenuButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-popover</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructMenuButtonUsePopover :: (IsMenuButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>MenuButton</a> widget with downwards-pointing arrow
--   as the only child. You can replace the child widget with another
--   <a>Widget</a> should you wish to.
--   
--   <i>Since: 3.6</i>
menuButtonNew :: (HasCallStack, MonadIO m) => m MenuButton

-- | Returns the parent <a>Widget</a> to use to line up with menu.
--   
--   <i>Since: 3.6</i>
menuButtonGetAlignWidget :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m (Maybe Widget)

-- | Returns the direction the popup will be pointing at when popped up.
--   
--   <i>Since: 3.6</i>
menuButtonGetDirection :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m ArrowType

-- | Returns the <a>MenuModel</a> used to generate the popup.
--   
--   <i>Since: 3.6</i>
menuButtonGetMenuModel :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m (Maybe MenuModel)

-- | Returns the <a>Popover</a> that pops out of the button. If the button
--   is not using a <a>Popover</a>, this function returns <a>Nothing</a>.
--   
--   <i>Since: 3.12</i>
menuButtonGetPopover :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m (Maybe Popover)

-- | Returns the <a>Menu</a> that pops out of the button. If the button
--   does not use a <a>Menu</a>, this function returns <a>Nothing</a>.
--   
--   <i>Since: 3.6</i>
menuButtonGetPopup :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m (Maybe Menu)

-- | Returns whether a <a>Popover</a> or a <a>Menu</a> will be constructed
--   from the menu model.
--   
--   <i>Since: 3.12</i>
menuButtonGetUsePopover :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m Bool

-- | Sets the <a>Widget</a> to use to line the menu with when popped up.
--   Note that the <i><tt>alignWidget</tt></i> must contain the
--   <a>MenuButton</a> itself.
--   
--   Setting it to <a>Nothing</a> means that the menu will be aligned with
--   the button itself.
--   
--   Note that this property is only used with menus currently, and not for
--   popovers.
--   
--   <i>Since: 3.6</i>
menuButtonSetAlignWidget :: (HasCallStack, MonadIO m, IsMenuButton a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the direction in which the popup will be popped up, as well as
--   changing the arrow’s direction. The child will not be changed to an
--   arrow if it was customized.
--   
--   If the does not fit in the available space in the given direction,
--   GTK+ will its best to keep it inside the screen and fully visible.
--   
--   If you pass <a>ArrowTypeNone</a> for a <i><tt>direction</tt></i>, the
--   popup will behave as if you passed <a>ArrowTypeDown</a> (although you
--   won’t see any arrows).
--   
--   <i>Since: 3.6</i>
menuButtonSetDirection :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> ArrowType -> m ()

-- | Sets the <a>MenuModel</a> from which the popup will be constructed, or
--   <a>Nothing</a> to dissociate any existing menu model and disable the
--   button.
--   
--   Depending on the value of <a>MenuButton:usePopover</a>, either a
--   <a>Menu</a> will be created with <a>menuNewFromModel</a>, or a
--   <a>Popover</a> with <a>popoverNewFromModel</a>. In either case,
--   actions will be connected as documented for these functions.
--   
--   If <a>MenuButton:popup</a> or <a>MenuButton:popover</a> are already
--   set, those widgets are dissociated from the
--   <i><tt>menuButton</tt></i>, and those properties are set to
--   <a>Nothing</a>.
--   
--   <i>Since: 3.6</i>
menuButtonSetMenuModel :: (HasCallStack, MonadIO m, IsMenuButton a, IsMenuModel b) => a -> Maybe b -> m ()

-- | Sets the <a>Popover</a> that will be popped up when the
--   <i><tt>menuButton</tt></i> is clicked, or <a>Nothing</a> to dissociate
--   any existing popover and disable the button.
--   
--   If <a>MenuButton:menuModel</a> or <a>MenuButton:popup</a> are set,
--   those objects are dissociated from the <i><tt>menuButton</tt></i>, and
--   those properties are set to <a>Nothing</a>.
--   
--   <i>Since: 3.12</i>
menuButtonSetPopover :: (HasCallStack, MonadIO m, IsMenuButton a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the <a>Menu</a> that will be popped up when the
--   <i><tt>menuButton</tt></i> is clicked, or <a>Nothing</a> to dissociate
--   any existing menu and disable the button.
--   
--   If <a>MenuButton:menuModel</a> or <a>MenuButton:popover</a> are set,
--   those objects are dissociated from the <i><tt>menuButton</tt></i>, and
--   those properties are set to <a>Nothing</a>.
--   
--   <i>Since: 3.6</i>
menuButtonSetPopup :: (HasCallStack, MonadIO m, IsMenuButton a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether to construct a <a>Popover</a> instead of <a>Menu</a> when
--   <a>menuButtonSetMenuModel</a> is called. Note that this property is
--   only consulted when a new menu model is set.
--   
--   <i>Since: 3.12</i>
menuButtonSetUsePopover :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> Bool -> m ()

-- | Cast to <a>LockButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toLockButton :: (MonadIO m, IsLockButton o) => o -> m LockButton

-- | Get the value of the “<tt>permission</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> lockButton #permission
--   </pre>
getLockButtonPermission :: (MonadIO m, IsLockButton o) => o -> m Permission

-- | Set the value of the “<tt>permission</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> lockButton [ #permission <a>:=</a> value ]
--   </pre>
setLockButtonPermission :: (MonadIO m, IsLockButton o, IsPermission a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>permission</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLockButtonPermission :: (IsLockButton o, MonadIO m, IsPermission a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>permission</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #permission
--   </pre>
clearLockButtonPermission :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Get the value of the “<tt>text-lock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> lockButton #textLock
--   </pre>
getLockButtonTextLock :: (MonadIO m, IsLockButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>text-lock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> lockButton [ #textLock <a>:=</a> value ]
--   </pre>
setLockButtonTextLock :: (MonadIO m, IsLockButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-lock</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLockButtonTextLock :: (IsLockButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>text-lock</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #textLock
--   </pre>
clearLockButtonTextLock :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Get the value of the “<tt>text-unlock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> lockButton #textUnlock
--   </pre>
getLockButtonTextUnlock :: (MonadIO m, IsLockButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>text-unlock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> lockButton [ #textUnlock <a>:=</a> value ]
--   </pre>
setLockButtonTextUnlock :: (MonadIO m, IsLockButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-unlock</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructLockButtonTextUnlock :: (IsLockButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>text-unlock</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #textUnlock
--   </pre>
clearLockButtonTextUnlock :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Get the value of the “<tt>tooltip-lock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> lockButton #tooltipLock
--   </pre>
getLockButtonTooltipLock :: (MonadIO m, IsLockButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>tooltip-lock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> lockButton [ #tooltipLock <a>:=</a> value ]
--   </pre>
setLockButtonTooltipLock :: (MonadIO m, IsLockButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip-lock</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructLockButtonTooltipLock :: (IsLockButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>tooltip-lock</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #tooltipLock
--   </pre>
clearLockButtonTooltipLock :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Get the value of the “<tt>tooltip-not-authorized</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> lockButton #tooltipNotAuthorized
--   </pre>
getLockButtonTooltipNotAuthorized :: (MonadIO m, IsLockButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>tooltip-not-authorized</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> lockButton [ #tooltipNotAuthorized <a>:=</a> value ]
--   </pre>
setLockButtonTooltipNotAuthorized :: (MonadIO m, IsLockButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip-not-authorized</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructLockButtonTooltipNotAuthorized :: (IsLockButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>tooltip-not-authorized</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #tooltipNotAuthorized
--   </pre>
clearLockButtonTooltipNotAuthorized :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Get the value of the “<tt>tooltip-unlock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> lockButton #tooltipUnlock
--   </pre>
getLockButtonTooltipUnlock :: (MonadIO m, IsLockButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>tooltip-unlock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> lockButton [ #tooltipUnlock <a>:=</a> value ]
--   </pre>
setLockButtonTooltipUnlock :: (MonadIO m, IsLockButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip-unlock</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructLockButtonTooltipUnlock :: (IsLockButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>tooltip-unlock</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #tooltipUnlock
--   </pre>
clearLockButtonTooltipUnlock :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Creates a new lock button which reflects the
--   <i><tt>permission</tt></i>.
--   
--   <i>Since: 3.2</i>
lockButtonNew :: (HasCallStack, MonadIO m, IsPermission a) => Maybe a -> m LockButton

-- | Obtains the <a>Permission</a> object that controls
--   <i><tt>button</tt></i>.
--   
--   <i>Since: 3.2</i>
lockButtonGetPermission :: (HasCallStack, MonadIO m, IsLockButton a) => a -> m Permission

-- | Sets the <a>Permission</a> object that controls
--   <i><tt>button</tt></i>.
--   
--   <i>Since: 3.2</i>
lockButtonSetPermission :: (HasCallStack, MonadIO m, IsLockButton a, IsPermission b) => a -> Maybe b -> m ()

-- | Cast to <a>LinkButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toLinkButton :: (MonadIO m, IsLinkButton o) => o -> m LinkButton

-- | Connect a signal handler for the <a>activateLink</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> linkButton #activateLink callback
--   </pre>
onLinkButtonActivateLink :: (IsLinkButton a, MonadIO m) => a -> ((?self :: a) => LinkButtonActivateLinkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateLink</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> linkButton #activateLink callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterLinkButtonActivateLink :: (IsLinkButton a, MonadIO m) => a -> ((?self :: a) => LinkButtonActivateLinkCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>uri</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> linkButton #uri
--   </pre>
getLinkButtonUri :: (MonadIO m, IsLinkButton o) => o -> m Text

-- | Set the value of the “<tt>uri</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> linkButton [ #uri <a>:=</a> value ]
--   </pre>
setLinkButtonUri :: (MonadIO m, IsLinkButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>uri</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLinkButtonUri :: (IsLinkButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>visited</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> linkButton #visited
--   </pre>
getLinkButtonVisited :: (MonadIO m, IsLinkButton o) => o -> m Bool

-- | Set the value of the “<tt>visited</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> linkButton [ #visited <a>:=</a> value ]
--   </pre>
setLinkButtonVisited :: (MonadIO m, IsLinkButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visited</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLinkButtonVisited :: (IsLinkButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>LinkButton</a> with the URI as its text.
--   
--   <i>Since: 2.10</i>
linkButtonNew :: (HasCallStack, MonadIO m) => Text -> m LinkButton

-- | Creates a new <a>LinkButton</a> containing a label.
--   
--   <i>Since: 2.10</i>
linkButtonNewWithLabel :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> m LinkButton

-- | Retrieves the URI set using <a>linkButtonSetUri</a>.
--   
--   <i>Since: 2.10</i>
linkButtonGetUri :: (HasCallStack, MonadIO m, IsLinkButton a) => a -> m Text

-- | Retrieves the “visited” state of the URI where the <a>LinkButton</a>
--   points. The button becomes visited when it is clicked. If the URI is
--   changed on the button, the “visited” state is unset again.
--   
--   The state may also be changed using <a>linkButtonSetVisited</a>.
--   
--   <i>Since: 2.14</i>
linkButtonGetVisited :: (HasCallStack, MonadIO m, IsLinkButton a) => a -> m Bool

-- | Sets <i><tt>uri</tt></i> as the URI where the <a>LinkButton</a>
--   points. As a side-effect this unsets the “visited” state of the
--   button.
--   
--   <i>Since: 2.10</i>
linkButtonSetUri :: (HasCallStack, MonadIO m, IsLinkButton a) => a -> Text -> m ()

-- | Sets the “visited” state of the URI where the <a>LinkButton</a>
--   points. See <a>linkButtonGetVisited</a> for more details.
--   
--   <i>Since: 2.14</i>
linkButtonSetVisited :: (HasCallStack, MonadIO m, IsLinkButton a) => a -> Bool -> m ()

-- | Cast to <a>InfoBar</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toInfoBar :: (MonadIO m, IsInfoBar o) => o -> m InfoBar

-- | Connect a signal handler for the <a>close</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> infoBar #close callback
--   </pre>
onInfoBarClose :: (IsInfoBar a, MonadIO m) => a -> ((?self :: a) => InfoBarCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>close</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> infoBar #close callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterInfoBarClose :: (IsInfoBar a, MonadIO m) => a -> ((?self :: a) => InfoBarCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>response</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> infoBar #response callback
--   </pre>
onInfoBarResponse :: (IsInfoBar a, MonadIO m) => a -> ((?self :: a) => InfoBarResponseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>response</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> infoBar #response callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterInfoBarResponse :: (IsInfoBar a, MonadIO m) => a -> ((?self :: a) => InfoBarResponseCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>message-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> infoBar #messageType
--   </pre>
getInfoBarMessageType :: (MonadIO m, IsInfoBar o) => o -> m MessageType

-- | Set the value of the “<tt>message-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> infoBar [ #messageType <a>:=</a> value ]
--   </pre>
setInfoBarMessageType :: (MonadIO m, IsInfoBar o) => o -> MessageType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>message-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructInfoBarMessageType :: (IsInfoBar o, MonadIO m) => MessageType -> m (GValueConstruct o)

-- | Get the value of the “<tt>revealed</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> infoBar #revealed
--   </pre>
getInfoBarRevealed :: (MonadIO m, IsInfoBar o) => o -> m Bool

-- | Set the value of the “<tt>revealed</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> infoBar [ #revealed <a>:=</a> value ]
--   </pre>
setInfoBarRevealed :: (MonadIO m, IsInfoBar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>revealed</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructInfoBarRevealed :: (IsInfoBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-close-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> infoBar #showCloseButton
--   </pre>
getInfoBarShowCloseButton :: (MonadIO m, IsInfoBar o) => o -> m Bool

-- | Set the value of the “<tt>show-close-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> infoBar [ #showCloseButton <a>:=</a> value ]
--   </pre>
setInfoBarShowCloseButton :: (MonadIO m, IsInfoBar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-close-button</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructInfoBarShowCloseButton :: (IsInfoBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>InfoBar</a> object.
--   
--   <i>Since: 2.18</i>
infoBarNew :: (HasCallStack, MonadIO m) => m InfoBar

-- | Add an activatable widget to the action area of a <a>InfoBar</a>,
--   connecting a signal handler that will emit the
--   <a>InfoBar::response</a> signal on the message area when the widget is
--   activated. The widget is appended to the end of the message areas
--   action area.
--   
--   <i>Since: 2.18</i>
infoBarAddActionWidget :: (HasCallStack, MonadIO m, IsInfoBar a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Adds a button with the given text and sets things up so that clicking
--   the button will emit the “response” signal with the given response_id.
--   The button is appended to the end of the info bars's action area. The
--   button widget is returned, but usually you don't need it.
--   
--   <i>Since: 2.18</i>
infoBarAddButton :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> Text -> Int32 -> m Button

-- | Returns the action area of <i><tt>infoBar</tt></i>.
--   
--   <i>Since: 2.18</i>
infoBarGetActionArea :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> m Box

-- | Returns the content area of <i><tt>infoBar</tt></i>.
--   
--   <i>Since: 2.18</i>
infoBarGetContentArea :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> m Box

-- | Returns the message type of the message area.
--   
--   <i>Since: 2.18</i>
infoBarGetMessageType :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> m MessageType

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 3.22.29</i>
infoBarGetRevealed :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> m Bool

-- | Returns whether the widget will display a standard close button.
--   
--   <i>Since: 3.10</i>
infoBarGetShowCloseButton :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> m Bool

-- | Emits the “response” signal with the given <i><tt>responseId</tt></i>.
--   
--   <i>Since: 2.18</i>
infoBarResponse :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> Int32 -> m ()

-- | Sets the last widget in the info bar’s action area with the given
--   response_id as the default widget for the dialog. Pressing “Enter”
--   normally activates the default widget.
--   
--   Note that this function currently requires <i><tt>infoBar</tt></i> to
--   be added to a widget hierarchy.
--   
--   <i>Since: 2.18</i>
infoBarSetDefaultResponse :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> Int32 -> m ()

-- | Sets the message type of the message area.
--   
--   GTK+ uses this type to determine how the message is displayed.
--   
--   <i>Since: 2.18</i>
infoBarSetMessageType :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> MessageType -> m ()

-- | Calls gtk_widget_set_sensitive (widget, setting) for each widget in
--   the info bars’s action area with the given response_id. A convenient
--   way to sensitize/desensitize dialog buttons.
--   
--   <i>Since: 2.18</i>
infoBarSetResponseSensitive :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> Int32 -> Bool -> m ()

-- | Sets the GtkInfoBar:revealed property to <i><tt>revealed</tt></i>.
--   This will cause <i><tt>infoBar</tt></i> to show up with a slide-in
--   transition.
--   
--   Note that this property does not automatically show
--   <i><tt>infoBar</tt></i> and thus won’t have any effect if it is
--   invisible.
--   
--   <i>Since: 3.22.29</i>
infoBarSetRevealed :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> Bool -> m ()

-- | If true, a standard close button is shown. When clicked it emits the
--   response <a>ResponseTypeClose</a>.
--   
--   <i>Since: 3.10</i>
infoBarSetShowCloseButton :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> Bool -> m ()

-- | Cast to <a>FontButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFontButton :: (MonadIO m, IsFontButton o) => o -> m FontButton

-- | Connect a signal handler for the <a>fontSet</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> fontButton #fontSet callback
--   </pre>
onFontButtonFontSet :: (IsFontButton a, MonadIO m) => a -> ((?self :: a) => FontButtonFontSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>fontSet</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> fontButton #fontSet callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFontButtonFontSet :: (IsFontButton a, MonadIO m) => a -> ((?self :: a) => FontButtonFontSetCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>font-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontButton #fontName
--   </pre>
getFontButtonFontName :: (MonadIO m, IsFontButton o) => o -> m Text

-- | Set the value of the “<tt>font-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontButton [ #fontName <a>:=</a> value ]
--   </pre>
setFontButtonFontName :: (MonadIO m, IsFontButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontButtonFontName :: (IsFontButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>font-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #fontName
--   </pre>
clearFontButtonFontName :: (MonadIO m, IsFontButton o) => o -> m ()

-- | Get the value of the “<tt>show-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontButton #showSize
--   </pre>
getFontButtonShowSize :: (MonadIO m, IsFontButton o) => o -> m Bool

-- | Set the value of the “<tt>show-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontButton [ #showSize <a>:=</a> value ]
--   </pre>
setFontButtonShowSize :: (MonadIO m, IsFontButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-size</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontButtonShowSize :: (IsFontButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontButton #showStyle
--   </pre>
getFontButtonShowStyle :: (MonadIO m, IsFontButton o) => o -> m Bool

-- | Set the value of the “<tt>show-style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontButton [ #showStyle <a>:=</a> value ]
--   </pre>
setFontButtonShowStyle :: (MonadIO m, IsFontButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-style</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontButtonShowStyle :: (IsFontButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontButton #title
--   </pre>
getFontButtonTitle :: (MonadIO m, IsFontButton o) => o -> m Text

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontButton [ #title <a>:=</a> value ]
--   </pre>
setFontButtonTitle :: (MonadIO m, IsFontButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFontButtonTitle :: (IsFontButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-font</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontButton #useFont
--   </pre>
getFontButtonUseFont :: (MonadIO m, IsFontButton o) => o -> m Bool

-- | Set the value of the “<tt>use-font</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontButton [ #useFont <a>:=</a> value ]
--   </pre>
setFontButtonUseFont :: (MonadIO m, IsFontButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-font</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontButtonUseFont :: (IsFontButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontButton #useSize
--   </pre>
getFontButtonUseSize :: (MonadIO m, IsFontButton o) => o -> m Bool

-- | Set the value of the “<tt>use-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontButton [ #useSize <a>:=</a> value ]
--   </pre>
setFontButtonUseSize :: (MonadIO m, IsFontButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-size</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontButtonUseSize :: (IsFontButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new font picker widget.
--   
--   <i>Since: 2.4</i>
fontButtonNew :: (HasCallStack, MonadIO m) => m FontButton

-- | Creates a new font picker widget.
--   
--   <i>Since: 2.4</i>
fontButtonNewWithFont :: (HasCallStack, MonadIO m) => Text -> m FontButton

-- | Retrieves the name of the currently selected font. This name includes
--   style and size information as well. If you want to render something
--   with the font, use this string with <a>fontDescriptionFromString</a> .
--   If you’re interested in peeking certain values (family name, style,
--   size, weight) just query these properties from the
--   <a>FontDescription</a> object.
--   
--   <i>Since: 2.4</i>
fontButtonGetFontName :: (HasCallStack, MonadIO m, IsFontButton a) => a -> m Text

-- | Returns whether the font size will be shown in the label.
--   
--   <i>Since: 2.4</i>
fontButtonGetShowSize :: (HasCallStack, MonadIO m, IsFontButton a) => a -> m Bool

-- | Returns whether the name of the font style will be shown in the label.
--   
--   <i>Since: 2.4</i>
fontButtonGetShowStyle :: (HasCallStack, MonadIO m, IsFontButton a) => a -> m Bool

-- | Retrieves the title of the font chooser dialog.
--   
--   <i>Since: 2.4</i>
fontButtonGetTitle :: (HasCallStack, MonadIO m, IsFontButton a) => a -> m Text

-- | Returns whether the selected font is used in the label.
--   
--   <i>Since: 2.4</i>
fontButtonGetUseFont :: (HasCallStack, MonadIO m, IsFontButton a) => a -> m Bool

-- | Returns whether the selected size is used in the label.
--   
--   <i>Since: 2.4</i>
fontButtonGetUseSize :: (HasCallStack, MonadIO m, IsFontButton a) => a -> m Bool

-- | Sets or updates the currently-displayed font in font picker dialog.
--   
--   <i>Since: 2.4</i>
fontButtonSetFontName :: (HasCallStack, MonadIO m, IsFontButton a) => a -> Text -> m Bool

-- | If <i><tt>showSize</tt></i> is <a>True</a>, the font size will be
--   displayed along with the name of the selected font.
--   
--   <i>Since: 2.4</i>
fontButtonSetShowSize :: (HasCallStack, MonadIO m, IsFontButton a) => a -> Bool -> m ()

-- | If <i><tt>showStyle</tt></i> is <a>True</a>, the font style will be
--   displayed along with name of the selected font.
--   
--   <i>Since: 2.4</i>
fontButtonSetShowStyle :: (HasCallStack, MonadIO m, IsFontButton a) => a -> Bool -> m ()

-- | Sets the title for the font chooser dialog.
--   
--   <i>Since: 2.4</i>
fontButtonSetTitle :: (HasCallStack, MonadIO m, IsFontButton a) => a -> Text -> m ()

-- | If <i><tt>useFont</tt></i> is <a>True</a>, the font name will be
--   written using the selected font.
--   
--   <i>Since: 2.4</i>
fontButtonSetUseFont :: (HasCallStack, MonadIO m, IsFontButton a) => a -> Bool -> m ()

-- | If <i><tt>useSize</tt></i> is <a>True</a>, the font name will be
--   written using the selected size.
--   
--   <i>Since: 2.4</i>
fontButtonSetUseSize :: (HasCallStack, MonadIO m, IsFontButton a) => a -> Bool -> m ()

-- | Cast to <a>ColorButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toColorButton :: (MonadIO m, IsColorButton o) => o -> m ColorButton

-- | Connect a signal handler for the <a>colorSet</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> colorButton #colorSet callback
--   </pre>
onColorButtonColorSet :: (IsColorButton a, MonadIO m) => a -> ((?self :: a) => ColorButtonColorSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>colorSet</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> colorButton #colorSet callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterColorButtonColorSet :: (IsColorButton a, MonadIO m) => a -> ((?self :: a) => ColorButtonColorSetCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>alpha</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorButton #alpha
--   </pre>
getColorButtonAlpha :: (MonadIO m, IsColorButton o) => o -> m Word32

-- | Set the value of the “<tt>alpha</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorButton [ #alpha <a>:=</a> value ]
--   </pre>
setColorButtonAlpha :: (MonadIO m, IsColorButton o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>alpha</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColorButtonAlpha :: (IsColorButton o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>color</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorButton #color
--   </pre>
getColorButtonColor :: (MonadIO m, IsColorButton o) => o -> m (Maybe Color)

-- | Set the value of the “<tt>color</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorButton [ #color <a>:=</a> value ]
--   </pre>
setColorButtonColor :: (MonadIO m, IsColorButton o) => o -> Color -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>color</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColorButtonColor :: (IsColorButton o, MonadIO m) => Color -> m (GValueConstruct o)

-- | Get the value of the “<tt>rgba</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorButton #rgba
--   </pre>
getColorButtonRgba :: (MonadIO m, IsColorButton o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>rgba</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorButton [ #rgba <a>:=</a> value ]
--   </pre>
setColorButtonRgba :: (MonadIO m, IsColorButton o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rgba</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColorButtonRgba :: (IsColorButton o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Set the value of the “<tt>rgba</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #rgba
--   </pre>
clearColorButtonRgba :: (MonadIO m, IsColorButton o) => o -> m ()

-- | Get the value of the “<tt>show-editor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorButton #showEditor
--   </pre>
getColorButtonShowEditor :: (MonadIO m, IsColorButton o) => o -> m Bool

-- | Set the value of the “<tt>show-editor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorButton [ #showEditor <a>:=</a> value ]
--   </pre>
setColorButtonShowEditor :: (MonadIO m, IsColorButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-editor</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructColorButtonShowEditor :: (IsColorButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorButton #title
--   </pre>
getColorButtonTitle :: (MonadIO m, IsColorButton o) => o -> m Text

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorButton [ #title <a>:=</a> value ]
--   </pre>
setColorButtonTitle :: (MonadIO m, IsColorButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColorButtonTitle :: (IsColorButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-alpha</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorButton #useAlpha
--   </pre>
getColorButtonUseAlpha :: (MonadIO m, IsColorButton o) => o -> m Bool

-- | Set the value of the “<tt>use-alpha</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorButton [ #useAlpha <a>:=</a> value ]
--   </pre>
setColorButtonUseAlpha :: (MonadIO m, IsColorButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-alpha</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructColorButtonUseAlpha :: (IsColorButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new color button.
--   
--   This returns a widget in the form of a small button containing a
--   swatch representing the current selected color. When the button is
--   clicked, a color-selection dialog will open, allowing the user to
--   select a color. The swatch will be updated to reflect the new color
--   when the user finishes.
--   
--   <i>Since: 2.4</i>
colorButtonNew :: (HasCallStack, MonadIO m) => m ColorButton

-- | Creates a new color button.
--   
--   <i>Since: 2.4</i>
colorButtonNewWithColor :: (HasCallStack, MonadIO m) => Color -> m ColorButton

-- | Creates a new color button.
--   
--   <i>Since: 3.0</i>
colorButtonNewWithRgba :: (HasCallStack, MonadIO m) => RGBA -> m ColorButton

-- | Returns the current alpha value.
--   
--   <i>Since: 2.4</i>
colorButtonGetAlpha :: (HasCallStack, MonadIO m, IsColorButton a) => a -> m Word16

-- | Sets <i><tt>color</tt></i> to be the current color in the
--   <a>ColorButton</a> widget.
--   
--   <i>Since: 2.4</i>
colorButtonGetColor :: (HasCallStack, MonadIO m, IsColorButton a) => a -> m Color

-- | Gets the title of the color selection dialog.
--   
--   <i>Since: 2.4</i>
colorButtonGetTitle :: (HasCallStack, MonadIO m, IsColorButton a) => a -> m Text

-- | Does the color selection dialog use the alpha channel ?
--   
--   <i>Since: 2.4</i>
colorButtonGetUseAlpha :: (HasCallStack, MonadIO m, IsColorButton a) => a -> m Bool

-- | Sets the current opacity to be <i><tt>alpha</tt></i>.
--   
--   <i>Since: 2.4</i>
colorButtonSetAlpha :: (HasCallStack, MonadIO m, IsColorButton a) => a -> Word16 -> m ()

-- | Sets the current color to be <i><tt>color</tt></i>.
--   
--   <i>Since: 2.4</i>
colorButtonSetColor :: (HasCallStack, MonadIO m, IsColorButton a) => a -> Color -> m ()

-- | Sets the title for the color selection dialog.
--   
--   <i>Since: 2.4</i>
colorButtonSetTitle :: (HasCallStack, MonadIO m, IsColorButton a) => a -> Text -> m ()

-- | Sets whether or not the color button should use the alpha channel.
--   
--   <i>Since: 2.4</i>
colorButtonSetUseAlpha :: (HasCallStack, MonadIO m, IsColorButton a) => a -> Bool -> m ()

-- | Cast to <a>CheckButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCheckButton :: (MonadIO m, IsCheckButton o) => o -> m CheckButton

-- | Creates a new <a>CheckButton</a>.
checkButtonNew :: (HasCallStack, MonadIO m) => m CheckButton

-- | Creates a new <a>CheckButton</a> with a <a>Label</a> to the right of
--   it.
checkButtonNewWithLabel :: (HasCallStack, MonadIO m) => Text -> m CheckButton

-- | Creates a new <a>CheckButton</a> containing a label. The label will be
--   created using <a>labelNewWithMnemonic</a>, so underscores in
--   <i><tt>label</tt></i> indicate the mnemonic for the check button.
checkButtonNewWithMnemonic :: (HasCallStack, MonadIO m) => Text -> m CheckButton

-- | Cast to <a>RadioButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toRadioButton :: (MonadIO m, IsRadioButton o) => o -> m RadioButton

-- | Connect a signal handler for the <a>groupChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> radioButton #groupChanged callback
--   </pre>
onRadioButtonGroupChanged :: (IsRadioButton a, MonadIO m) => a -> ((?self :: a) => RadioButtonGroupChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>groupChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> radioButton #groupChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterRadioButtonGroupChanged :: (IsRadioButton a, MonadIO m) => a -> ((?self :: a) => RadioButtonGroupChangedCallback) -> m SignalHandlerId

-- | Set the value of the “<tt>group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> radioButton [ #group <a>:=</a> value ]
--   </pre>
setRadioButtonGroup :: (MonadIO m, IsRadioButton o, IsRadioButton a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>group</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructRadioButtonGroup :: (IsRadioButton o, MonadIO m, IsRadioButton a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>group</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #group
--   </pre>
clearRadioButtonGroup :: (MonadIO m, IsRadioButton o) => o -> m ()

-- | Creates a new <a>RadioButton</a>. To be of any practical value, a
--   widget should then be packed into the radio button.
radioButtonNew :: (HasCallStack, MonadIO m, IsRadioButton a) => [a] -> m RadioButton

-- | Creates a new <a>RadioButton</a>, adding it to the same group as
--   <i><tt>radioGroupMember</tt></i>. As with <a>radioButtonNew</a>, a
--   widget should be packed into the radio button.
radioButtonNewFromWidget :: (HasCallStack, MonadIO m, IsRadioButton a) => Maybe a -> m RadioButton

-- | Creates a new <a>RadioButton</a> with a text label.
radioButtonNewWithLabel :: (HasCallStack, MonadIO m, IsRadioButton a) => [a] -> Text -> m RadioButton

-- | Creates a new <a>RadioButton</a> with a text label, adding it to the
--   same group as <i><tt>radioGroupMember</tt></i>.
radioButtonNewWithLabelFromWidget :: (HasCallStack, MonadIO m, IsRadioButton a) => Maybe a -> Text -> m RadioButton

-- | Creates a new <a>RadioButton</a> containing a label, adding it to the
--   same group as <i><tt>group</tt></i>. The label will be created using
--   <a>labelNewWithMnemonic</a>, so underscores in <i><tt>label</tt></i>
--   indicate the mnemonic for the button.
radioButtonNewWithMnemonic :: (HasCallStack, MonadIO m, IsRadioButton a) => [a] -> Text -> m RadioButton

-- | Creates a new <a>RadioButton</a> containing a label. The label will be
--   created using <a>labelNewWithMnemonic</a>, so underscores in
--   <i><tt>label</tt></i> indicate the mnemonic for the button.
radioButtonNewWithMnemonicFromWidget :: (HasCallStack, MonadIO m, IsRadioButton a) => Maybe a -> Text -> m RadioButton

-- | Retrieves the group assigned to a radio button.
radioButtonGetGroup :: (HasCallStack, MonadIO m, IsRadioButton a) => a -> m [RadioButton]

-- | Joins a <a>RadioButton</a> object to the group of another
--   <a>RadioButton</a> object
--   
--   Use this in language bindings instead of the
--   <a>radioButtonGetGroup</a> and <a>radioButtonSetGroup</a> methods
--   
--   A common way to set up a group of radio buttons is the following:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GtkRadioButton *radio_button;
--   GtkRadioButton *last_button;
--   
--   while (some_condition)
--     {
--        radio_button = gtk_radio_button_new (NULL);
--   
--        gtk_radio_button_join_group (radio_button, last_button);
--        last_button = radio_button;
--     }
--   </pre>
--   
--   <i>Since: 3.0</i>
radioButtonJoinGroup :: (HasCallStack, MonadIO m, IsRadioButton a, IsRadioButton b) => a -> Maybe b -> m ()

-- | Sets a <a>RadioButton</a>’s group. It should be noted that this does
--   not change the layout of your interface in any way, so if you are
--   changing the group, it is likely you will need to re-arrange the user
--   interface to reflect these changes.
radioButtonSetGroup :: (HasCallStack, MonadIO m, IsRadioButton a, IsRadioButton b) => a -> [b] -> m ()

-- | Cast to <a>RadioToolButton</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toRadioToolButton :: (MonadIO m, IsRadioToolButton o) => o -> m RadioToolButton

-- | Set the value of the “<tt>group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> radioToolButton [ #group <a>:=</a> value ]
--   </pre>
setRadioToolButtonGroup :: (MonadIO m, IsRadioToolButton o, IsRadioToolButton a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>group</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructRadioToolButtonGroup :: (IsRadioToolButton o, MonadIO m, IsRadioToolButton a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>group</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #group
--   </pre>
clearRadioToolButtonGroup :: (MonadIO m, IsRadioToolButton o) => o -> m ()

-- | Creates a new <a>RadioToolButton</a>, adding it to
--   <i><tt>group</tt></i>.
--   
--   <i>Since: 2.4</i>
radioToolButtonNew :: (HasCallStack, MonadIO m, IsRadioButton a) => [a] -> m RadioToolButton

-- | Creates a new <a>RadioToolButton</a>, adding it to
--   <i><tt>group</tt></i>. The new <a>RadioToolButton</a> will contain an
--   icon and label from the stock item indicated by
--   <i><tt>stockId</tt></i>.
--   
--   <i>Since: 2.4</i>
radioToolButtonNewFromStock :: (HasCallStack, MonadIO m, IsRadioButton a) => [a] -> Text -> m RadioToolButton

-- | Creates a new <a>RadioToolButton</a> adding it to the same group as
--   <i><tt>gruup</tt></i>
--   
--   <i>Since: 2.4</i>
radioToolButtonNewFromWidget :: (HasCallStack, MonadIO m, IsRadioToolButton a) => Maybe a -> m RadioToolButton

-- | Creates a new <a>RadioToolButton</a> adding it to the same group as
--   <i><tt>group</tt></i>. The new <a>RadioToolButton</a> will contain an
--   icon and label from the stock item indicated by
--   <i><tt>stockId</tt></i>.
--   
--   <i>Since: 2.4</i>
radioToolButtonNewWithStockFromWidget :: (HasCallStack, MonadIO m, IsRadioToolButton a) => Maybe a -> Text -> m RadioToolButton

-- | Returns the radio button group <i><tt>button</tt></i> belongs to.
--   
--   <i>Since: 2.4</i>
radioToolButtonGetGroup :: (HasCallStack, MonadIO m, IsRadioToolButton a) => a -> m [RadioButton]

-- | Adds <i><tt>button</tt></i> to <i><tt>group</tt></i>, removing it from
--   the group it belonged to before.
--   
--   <i>Since: 2.4</i>
radioToolButtonSetGroup :: (HasCallStack, MonadIO m, IsRadioToolButton a, IsRadioButton b) => a -> [b] -> m ()

-- | Cast to <a>AppChooserWidget</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toAppChooserWidget :: (MonadIO m, IsAppChooserWidget o) => o -> m AppChooserWidget

-- | Connect a signal handler for the <a>applicationActivated</a> signal,
--   to be run before the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> appChooserWidget #applicationActivated callback
--   </pre>
onAppChooserWidgetApplicationActivated :: (IsAppChooserWidget a, MonadIO m) => a -> ((?self :: a) => AppChooserWidgetApplicationActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>applicationActivated</a> signal,
--   to be run after the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> appChooserWidget #applicationActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAppChooserWidgetApplicationActivated :: (IsAppChooserWidget a, MonadIO m) => a -> ((?self :: a) => AppChooserWidgetApplicationActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>applicationSelected</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> appChooserWidget #applicationSelected callback
--   </pre>
onAppChooserWidgetApplicationSelected :: (IsAppChooserWidget a, MonadIO m) => a -> ((?self :: a) => AppChooserWidgetApplicationSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>applicationSelected</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> appChooserWidget #applicationSelected callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAppChooserWidgetApplicationSelected :: (IsAppChooserWidget a, MonadIO m) => a -> ((?self :: a) => AppChooserWidgetApplicationSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>populatePopup</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> appChooserWidget #populatePopup callback
--   </pre>
onAppChooserWidgetPopulatePopup :: (IsAppChooserWidget a, MonadIO m) => a -> ((?self :: a) => AppChooserWidgetPopulatePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>populatePopup</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> appChooserWidget #populatePopup callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAppChooserWidgetPopulatePopup :: (IsAppChooserWidget a, MonadIO m) => a -> ((?self :: a) => AppChooserWidgetPopulatePopupCallback) -> m SignalHandlerId

-- | Get the value of the “<tt>default-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserWidget #defaultText
--   </pre>
getAppChooserWidgetDefaultText :: (MonadIO m, IsAppChooserWidget o) => o -> m Text

-- | Set the value of the “<tt>default-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserWidget [ #defaultText <a>:=</a> value ]
--   </pre>
setAppChooserWidgetDefaultText :: (MonadIO m, IsAppChooserWidget o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>default-text</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAppChooserWidgetDefaultText :: (IsAppChooserWidget o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-all</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserWidget #showAll
--   </pre>
getAppChooserWidgetShowAll :: (MonadIO m, IsAppChooserWidget o) => o -> m Bool

-- | Set the value of the “<tt>show-all</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserWidget [ #showAll <a>:=</a> value ]
--   </pre>
setAppChooserWidgetShowAll :: (MonadIO m, IsAppChooserWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-all</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructAppChooserWidgetShowAll :: (IsAppChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserWidget #showDefault
--   </pre>
getAppChooserWidgetShowDefault :: (MonadIO m, IsAppChooserWidget o) => o -> m Bool

-- | Set the value of the “<tt>show-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserWidget [ #showDefault <a>:=</a> value ]
--   </pre>
setAppChooserWidgetShowDefault :: (MonadIO m, IsAppChooserWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-default</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAppChooserWidgetShowDefault :: (IsAppChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-fallback</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserWidget #showFallback
--   </pre>
getAppChooserWidgetShowFallback :: (MonadIO m, IsAppChooserWidget o) => o -> m Bool

-- | Set the value of the “<tt>show-fallback</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserWidget [ #showFallback <a>:=</a> value ]
--   </pre>
setAppChooserWidgetShowFallback :: (MonadIO m, IsAppChooserWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-fallback</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAppChooserWidgetShowFallback :: (IsAppChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-other</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserWidget #showOther
--   </pre>
getAppChooserWidgetShowOther :: (MonadIO m, IsAppChooserWidget o) => o -> m Bool

-- | Set the value of the “<tt>show-other</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserWidget [ #showOther <a>:=</a> value ]
--   </pre>
setAppChooserWidgetShowOther :: (MonadIO m, IsAppChooserWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-other</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructAppChooserWidgetShowOther :: (IsAppChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-recommended</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserWidget #showRecommended
--   </pre>
getAppChooserWidgetShowRecommended :: (MonadIO m, IsAppChooserWidget o) => o -> m Bool

-- | Set the value of the “<tt>show-recommended</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserWidget [ #showRecommended <a>:=</a> value ]
--   </pre>
setAppChooserWidgetShowRecommended :: (MonadIO m, IsAppChooserWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-recommended</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAppChooserWidgetShowRecommended :: (IsAppChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Creates a new <a>AppChooserWidget</a> for applications that can handle
--   content of the given type.
--   
--   <i>Since: 3.0</i>
appChooserWidgetNew :: (HasCallStack, MonadIO m) => Text -> m AppChooserWidget

-- | Returns the text that is shown if there are not applications that can
--   handle the content type.
--   
--   <i>Since: 3.0</i>
appChooserWidgetGetDefaultText :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m Text

-- | Returns the current value of the <a>AppChooserWidget:showAll</a>
--   property.
--   
--   <i>Since: 3.0</i>
appChooserWidgetGetShowAll :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m Bool

-- | Returns the current value of the <a>AppChooserWidget:showDefault</a>
--   property.
--   
--   <i>Since: 3.0</i>
appChooserWidgetGetShowDefault :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m Bool

-- | Returns the current value of the <a>AppChooserWidget:showFallback</a>
--   property.
--   
--   <i>Since: 3.0</i>
appChooserWidgetGetShowFallback :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m Bool

-- | Returns the current value of the <a>AppChooserWidget:showOther</a>
--   property.
--   
--   <i>Since: 3.0</i>
appChooserWidgetGetShowOther :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m Bool

-- | Returns the current value of the
--   <a>AppChooserWidget:showRecommended</a> property.
--   
--   <i>Since: 3.0</i>
appChooserWidgetGetShowRecommended :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m Bool

-- | Sets the text that is shown if there are not applications that can
--   handle the content type.
appChooserWidgetSetDefaultText :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> Text -> m ()

-- | Sets whether the app chooser should show all applications in a flat
--   list.
--   
--   <i>Since: 3.0</i>
appChooserWidgetSetShowAll :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> Bool -> m ()

-- | Sets whether the app chooser should show the default handler for the
--   content type in a separate section.
--   
--   <i>Since: 3.0</i>
appChooserWidgetSetShowDefault :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> Bool -> m ()

-- | Sets whether the app chooser should show related applications for the
--   content type in a separate section.
--   
--   <i>Since: 3.0</i>
appChooserWidgetSetShowFallback :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> Bool -> m ()

-- | Sets whether the app chooser should show applications which are
--   unrelated to the content type.
--   
--   <i>Since: 3.0</i>
appChooserWidgetSetShowOther :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> Bool -> m ()

-- | Sets whether the app chooser should show recommended applications for
--   the content type in a separate section.
--   
--   <i>Since: 3.0</i>
appChooserWidgetSetShowRecommended :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> Bool -> m ()

-- | Cast to <a>AccelLabel</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAccelLabel :: (MonadIO m, IsAccelLabel o) => o -> m AccelLabel

-- | Get the value of the “<tt>accel-closure</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> accelLabel #accelClosure
--   </pre>
getAccelLabelAccelClosure :: (MonadIO m, IsAccelLabel o) => o -> m (Maybe (GClosure ()))

-- | Set the value of the “<tt>accel-closure</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> accelLabel [ #accelClosure <a>:=</a> value ]
--   </pre>
setAccelLabelAccelClosure :: (MonadIO m, IsAccelLabel o) => o -> GClosure a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-closure</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAccelLabelAccelClosure :: (IsAccelLabel o, MonadIO m) => GClosure a -> m (GValueConstruct o)

-- | Set the value of the “<tt>accel-closure</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #accelClosure
--   </pre>
clearAccelLabelAccelClosure :: (MonadIO m, IsAccelLabel o) => o -> m ()

-- | Get the value of the “<tt>accel-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> accelLabel #accelWidget
--   </pre>
getAccelLabelAccelWidget :: (MonadIO m, IsAccelLabel o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>accel-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> accelLabel [ #accelWidget <a>:=</a> value ]
--   </pre>
setAccelLabelAccelWidget :: (MonadIO m, IsAccelLabel o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-widget</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAccelLabelAccelWidget :: (IsAccelLabel o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>accel-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #accelWidget
--   </pre>
clearAccelLabelAccelWidget :: (MonadIO m, IsAccelLabel o) => o -> m ()

-- | Creates a new <a>AccelLabel</a>.
accelLabelNew :: (HasCallStack, MonadIO m) => Text -> m AccelLabel

-- | Gets the keyval and modifier mask set with <a>accelLabelSetAccel</a>.
--   
--   <i>Since: 3.12</i>
accelLabelGetAccel :: (HasCallStack, MonadIO m, IsAccelLabel a) => a -> m (Word32, [ModifierType])

-- | Fetches the widget monitored by this accelerator label. See
--   <a>accelLabelSetAccelWidget</a>.
accelLabelGetAccelWidget :: (HasCallStack, MonadIO m, IsAccelLabel a) => a -> m (Maybe Widget)

-- | Returns the width needed to display the accelerator key(s). This is
--   used by menus to align all of the <a>MenuItem</a> widgets, and
--   shouldn't be needed by applications.
accelLabelGetAccelWidth :: (HasCallStack, MonadIO m, IsAccelLabel a) => a -> m Word32

-- | Recreates the string representing the accelerator keys. This should
--   not be needed since the string is automatically updated whenever
--   accelerators are added or removed from the associated widget.
accelLabelRefetch :: (HasCallStack, MonadIO m, IsAccelLabel a) => a -> m Bool

-- | Manually sets a keyval and modifier mask as the accelerator rendered
--   by <i><tt>accelLabel</tt></i>.
--   
--   If a keyval and modifier are explicitly set then these values are used
--   regardless of any associated accel closure or widget.
--   
--   Providing an <i><tt>acceleratorKey</tt></i> of 0 removes the manual
--   setting.
--   
--   <i>Since: 3.6</i>
accelLabelSetAccel :: (HasCallStack, MonadIO m, IsAccelLabel a) => a -> Word32 -> [ModifierType] -> m ()

-- | Sets the closure to be monitored by this accelerator label. The
--   closure must be connected to an accelerator group; see
--   <a>accelGroupConnect</a>. Passing <a>Nothing</a> for
--   <i><tt>accelClosure</tt></i> will dissociate
--   <i><tt>accelLabel</tt></i> from its current closure, if any.
accelLabelSetAccelClosure :: (HasCallStack, MonadIO m, IsAccelLabel a) => a -> Maybe (GClosure b) -> m ()

-- | Sets the widget to be monitored by this accelerator label. Passing
--   <a>Nothing</a> for <i><tt>accelWidget</tt></i> will dissociate
--   <i><tt>accelLabel</tt></i> from its current widget, if any.
accelLabelSetAccelWidget :: (HasCallStack, MonadIO m, IsAccelLabel a, IsWidget b) => a -> Maybe b -> m ()

-- | All this function does it to return <a>True</a>.
--   
--   This can be useful for example if you want to inhibit the deletion of
--   a window. Of course you should not do this as the user expects a
--   reaction from clicking the close icon of the window...
--   
--   <h2>A persistent window</h2>
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   #include &lt;gtk/gtk.h&gt;
--   
--   int
--   main (int argc, char **argv)
--   {
--     GtkWidget *win, *but;
--     const char *text = "Close yourself. I mean it!";
--   
--     gtk_init (&amp;argc, &amp;argv);
--   
--     win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
--     g_signal_connect (win,
--                       "delete-event",
--                       G_CALLBACK (gtk_true),
--                       NULL);
--     g_signal_connect (win, "destroy",
--                       G_CALLBACK (gtk_main_quit),
--                       NULL);
--   
--     but = gtk_button_new_with_label (text);
--     g_signal_connect_swapped (but, "clicked",
--                               G_CALLBACK (gtk_object_destroy),
--                               win);
--     gtk_container_add (GTK_CONTAINER (win), but);
--   
--     gtk_widget_show_all (win);
--   
--     gtk_main ();
--   
--     return 0;
--   }
--   </pre>
true :: (HasCallStack, MonadIO m) => m Bool

-- | Sets selection data of target type <tt><i>GTK_TREE_MODEL_ROW</i></tt>.
--   Normally used in a drag_data_get handler.
treeSetRowDragData :: (HasCallStack, MonadIO m, IsTreeModel a) => SelectionData -> a -> TreePath -> m Bool

-- | Obtains a <i><tt>treeModel</tt></i> and <i><tt>path</tt></i> from
--   selection data of target type <tt><i>GTK_TREE_MODEL_ROW</i></tt>.
--   Normally called from a drag_data_received handler. This function can
--   only be used if <i><tt>selectionData</tt></i> originates from the same
--   process that’s calling this function, because a pointer to the tree
--   model is being passed around. If you aren’t in the same process, then
--   you'll get memory corruption. In the <a>TreeDragDest</a>
--   drag_data_received handler, you can assume that selection data of type
--   <tt><i>GTK_TREE_MODEL_ROW</i></tt> is in from the current process. The
--   returned path must be freed with <a>treePathFree</a>.
treeGetRowDragData :: (HasCallStack, MonadIO m) => SelectionData -> m (Bool, Maybe TreeModel, Maybe TreePath)

-- | Enters the main loop and waits for <i><tt>widget</tt></i> to be
--   “drawn”. In this context that means it waits for the frame clock of
--   <i><tt>widget</tt></i> to have run a full styling, layout and drawing
--   cycle.
--   
--   This function is intended to be used for syncing with actions that
--   depend on <i><tt>widget</tt></i> relayouting or on interaction with
--   the display server.
--   
--   <i>Since: 3.10</i>
testWidgetWaitForDraw :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | This function will generate keyboard press and release events in the
--   middle of the first GdkWindow found that belongs to
--   <i><tt>widget</tt></i>. For windowless widgets like <a>Button</a>
--   (which returns <a>False</a> from <a>widgetGetHasWindow</a>), this will
--   often be an input-only event window. For other widgets, this is
--   usually widget-&gt;window. Certain caveats should be considered when
--   using this function, in particular because the mouse pointer is warped
--   to the key press location, see <a>testSimulateKey</a> for details.
--   
--   <i>Since: 2.14</i>
testWidgetSendKey :: (HasCallStack, MonadIO m, IsWidget a) => a -> Word32 -> [ModifierType] -> m Bool

-- | This function will generate a <i><tt>button</tt></i> click (button
--   press and button release event) in the middle of the first GdkWindow
--   found that belongs to <i><tt>widget</tt></i>. For windowless widgets
--   like <a>Button</a> (which returns <a>False</a> from
--   <a>widgetGetHasWindow</a>), this will often be an input-only event
--   window. For other widgets, this is usually widget-&gt;window. Certain
--   caveats should be considered when using this function, in particular
--   because the mouse pointer is warped to the button click location, see
--   <a>testSimulateButton</a> for details.
--   
--   <i>Since: 2.14</i>
testWidgetClick :: (HasCallStack, MonadIO m, IsWidget a) => a -> Word32 -> [ModifierType] -> m Bool

-- | Set the text string of <i><tt>widget</tt></i> to
--   <i><tt>string</tt></i> if it is a GtkLabel, GtkEditable (entry and
--   text widgets) or GtkTextView.
--   
--   <i>Since: 2.14</i>
testTextSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> m ()

-- | Retrive the text string of <i><tt>widget</tt></i> if it is a GtkLabel,
--   GtkEditable (entry and text widgets) or GtkTextView.
--   
--   <i>Since: 2.14</i>
testTextGet :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Text

-- | This function will generate a <i><tt>button</tt></i> click in the
--   upwards or downwards spin button arrow areas, usually leading to an
--   increase or decrease of spin button’s value.
--   
--   <i>Since: 2.14</i>
testSpinButtonClick :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Word32 -> Bool -> m Bool

-- | This function will adjust the slider position of all GtkRange based
--   widgets, such as scrollbars or scales, it’ll also adjust spin buttons.
--   The adjustment value of these widgets is set to a value between the
--   lower and upper limits, according to the <i><tt>percentage</tt></i>
--   argument.
--   
--   <i>Since: 2.14</i>
testSliderSetPerc :: (HasCallStack, MonadIO m, IsWidget a) => a -> Double -> m ()

-- | Retrive the literal adjustment value for GtkRange based widgets and
--   spin buttons. Note that the value returned by this function is
--   anything between the lower and upper bounds of the adjustment
--   belonging to <i><tt>widget</tt></i>, and is not a percentage as passed
--   in to <a>testSliderSetPerc</a>.
--   
--   <i>Since: 2.14</i>
testSliderGetValue :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Double

-- | Force registration of all core Gtk+ and Gdk object types. This allowes
--   to refer to any of those object types via <a>typeFromName</a> after
--   calling this function.
--   
--   <i>Since: 2.14</i>
testRegisterAllTypes :: (HasCallStack, MonadIO m) => m ()

-- | Return the type ids that have been registered after calling
--   <a>testRegisterAllTypes</a>.
--   
--   <i>Since: 2.14</i>
testListAllTypes :: (HasCallStack, MonadIO m) => m ([GType], Word32)

-- | This function will search the descendants of <i><tt>widget</tt></i>
--   for a widget of type <i><tt>widgetType</tt></i> that has a label
--   matching <i><tt>labelPattern</tt></i> next to it. This is most useful
--   for automated GUI testing, e.g. to find the “OK” button in a dialog
--   and synthesize clicks on it. However see <a>testFindLabel</a>,
--   <a>testFindSibling</a> and <a>testWidgetClick</a> for possible caveats
--   involving the search of such widgets and synthesizing widget events.
--   
--   <i>Since: 2.14</i>
testFindWidget :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> GType -> m (Maybe Widget)

-- | This function will search siblings of <i><tt>baseWidget</tt></i> and
--   siblings of its ancestors for all widgets matching
--   <i><tt>widgetType</tt></i>. Of the matching widgets, the one that is
--   geometrically closest to <i><tt>baseWidget</tt></i> will be returned.
--   The general purpose of this function is to find the most likely
--   “action” widget, relative to another labeling widget. Such as finding
--   a button or text entry widget, given its corresponding label widget.
--   
--   <i>Since: 2.14</i>
testFindSibling :: (HasCallStack, MonadIO m, IsWidget a) => a -> GType -> m Widget

-- | This function will search <i><tt>widget</tt></i> and all its
--   descendants for a GtkLabel widget with a text string matching
--   <i><tt>labelPattern</tt></i>. The <i><tt>labelPattern</tt></i> may
--   contain asterisks “*” and question marks “?” as placeholders,
--   <tt><i>g_pattern_match()</i></tt> is used for the matching. Note that
--   locales other than "C“ tend to alter (translate” label strings, so
--   this function is genrally only useful in test programs with
--   predetermined locales, see <tt><i>gtk_test_init()</i></tt> for more
--   details.
--   
--   <i>Since: 2.14</i>
testFindLabel :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> m Widget

-- | Create a simple window with window title <i><tt>windowTitle</tt></i>
--   and text contents <i><tt>dialogText</tt></i>. The window will quit any
--   running <a>main</a>-loop when destroyed, and it will automatically be
--   destroyed upon test function teardown.
--   
--   <i>Since: 2.14</i>
testCreateSimpleWindow :: (HasCallStack, MonadIO m) => Text -> Text -> m Widget

-- | Determines if any of the targets in <i><tt>targets</tt></i> can be
--   used to provide an uri list.
--   
--   <i>Since: 2.10</i>
targetsIncludeUri :: (HasCallStack, MonadIO m) => [Atom] -> m Bool

-- | Determines if any of the targets in <i><tt>targets</tt></i> can be
--   used to provide text.
--   
--   <i>Since: 2.10</i>
targetsIncludeText :: (HasCallStack, MonadIO m) => [Atom] -> m Bool

-- | Determines if any of the targets in <i><tt>targets</tt></i> can be
--   used to provide rich text.
--   
--   <i>Since: 2.10</i>
targetsIncludeRichText :: (HasCallStack, MonadIO m, IsTextBuffer a) => [Atom] -> a -> m Bool

-- | Determines if any of the targets in <i><tt>targets</tt></i> can be
--   used to provide a <a>Pixbuf</a>.
--   
--   <i>Since: 2.10</i>
targetsIncludeImage :: (HasCallStack, MonadIO m) => [Atom] -> Bool -> m Bool

-- | This function creates an <a>TargetEntry</a> array that contains the
--   same targets as the passed <tt><i>list</i></tt>. The returned table is
--   newly allocated and should be freed using <a>targetTableFree</a> when
--   no longer needed.
--   
--   <i>Since: 2.10</i>
targetTableNewFromList :: (HasCallStack, MonadIO m) => TargetList -> m [TargetEntry]

-- | This function frees a target table as returned by
--   <a>targetTableNewFromList</a>
--   
--   <i>Since: 2.10</i>
targetTableFree :: (HasCallStack, MonadIO m) => [TargetEntry] -> m ()

-- | Sets a function to be used for translating the <i><tt>label</tt></i>
--   of a stock item.
--   
--   If no function is registered for a translation domain, <a>dgettext</a>
--   is used.
--   
--   The function is used for all stock items whose
--   <i><tt>translationDomain</tt></i> matches <i><tt>domain</tt></i>. Note
--   that it is possible to use strings different from the actual gettext
--   translation domain of your application for this, as long as your
--   <a>TranslateFunc</a> uses the correct domain when calling
--   <tt><i>dgettext()</i></tt>. This can be useful, e.g. when dealing with
--   message contexts:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GtkStockItem items[] = {
--    { MY_ITEM1, NC_("odd items", "Item 1"), 0, 0, "odd-item-domain" },
--    { MY_ITEM2, NC_("even items", "Item 2"), 0, 0, "even-item-domain" },
--   };
--   
--   gchar *
--   my_translate_func (const gchar *msgid,
--                      gpointer     data)
--   {
--     gchar *msgctxt = data;
--   
--     return (gchar*)g_dpgettext2 (GETTEXT_PACKAGE, msgctxt, msgid);
--   }
--   
--   ...
--   
--   gtk_stock_add (items, G_N_ELEMENTS (items));
--   gtk_stock_set_translate_func ("odd-item-domain", my_translate_func, "odd items");
--   gtk_stock_set_translate_func ("even-item-domain", my_translate_func, "even items");
--   </pre>
--   
--   <i>Since: 2.8</i>
stockSetTranslateFunc :: (HasCallStack, MonadIO m) => Text -> TranslateFunc -> m ()

-- | Retrieves a list of all known stock IDs added to a <a>IconFactory</a>
--   or registered with <a>stockAdd</a>. The list must be freed with
--   <tt><i>g_slist_free()</i></tt>, and each string in the list must be
--   freed with <a>free</a>.
stockListIds :: (HasCallStack, MonadIO m) => m [Text]

-- | Same as <a>stockAdd</a>, but doesn’t copy <i><tt>items</tt></i>, so
--   <i><tt>items</tt></i> must persist until application exit.
stockAddStatic :: (HasCallStack, MonadIO m) => [StockItem] -> m ()

-- | Registers each of the stock items in <i><tt>items</tt></i>. If an item
--   already exists with the same stock ID as one of the
--   <i><tt>items</tt></i>, the old item gets replaced. The stock items are
--   copied, so GTK+ does not hold any pointer into <i><tt>items</tt></i>
--   and <i><tt>items</tt></i> can be freed. Use <a>stockAddStatic</a> if
--   <i><tt>items</tt></i> is persistent and GTK+ need not copy the array.
stockAdd :: (HasCallStack, MonadIO m) => [StockItem] -> m ()

-- | A convenience function for launching the default application to show
--   the uri. Like <a>showUriOnWindow</a>, but takes a screen as transient
--   parent instead of a window.
--   
--   Note that this function is deprecated as it does not pass the
--   necessary information for helpers to parent their dialog properly,
--   when run from sandboxed applications for example.
--   
--   <i>Since: 2.14</i>
showUri :: (HasCallStack, MonadIO m, IsScreen a) => Maybe a -> Text -> Word32 -> m ()

-- | Sets the GTK+ debug flags.
setDebugFlags :: (HasCallStack, MonadIO m) => Word32 -> m ()

-- | Removes all handlers and unsets ownership of all selections for a
--   widget. Called when widget is being destroyed. This function will not
--   generally be called by applications.
selectionRemoveAll :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Remove all targets registered for the given selection for the widget.
selectionClearTargets :: (HasCallStack, MonadIO m, IsWidget a) => a -> Atom -> m ()

-- | Prepends a table of targets to the list of supported targets for a
--   given widget and selection.
selectionAddTargets :: (HasCallStack, MonadIO m, IsWidget a) => a -> Atom -> [TargetEntry] -> m ()

-- | Appends a specified target to the list of supported targets for a
--   given widget and selection.
selectionAddTarget :: (HasCallStack, MonadIO m, IsWidget a) => a -> Atom -> Atom -> Word32 -> m ()

-- | Converts a color from RGB space to HSV.
--   
--   Input values must be in the [0.0, 1.0] range; output values will be in
--   the same range.
--   
--   <i>Since: 2.14</i>
rgbToHsv :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> m (Double, Double, Double)

-- | Renders a slider (as in <a>Scale</a>) in the rectangle defined by
--   <i><tt>x</tt></i>, <i><tt>y</tt></i>, <i><tt>width</tt></i>,
--   <i><tt>height</tt></i>. <i><tt>orientation</tt></i> defines whether
--   the slider is vertical or horizontal.
--   
--   Typical slider rendering:
--   
--   
--   <i>Since: 3.0</i>
renderSlider :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> Orientation -> m ()

-- | Renders an option mark (as in a <a>RadioButton</a>), the
--   <a>StateFlagsChecked</a> state will determine whether the option is on
--   or off, and <a>StateFlagsInconsistent</a> whether it should be marked
--   as undefined.
--   
--   Typical option mark rendering:
--   
--   
--   <i>Since: 3.0</i>
renderOption :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders a line from (x0, y0) to (x1, y1).
--   
--   <i>Since: 3.0</i>
renderLine :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders <i><tt>layout</tt></i> on the coordinates <i><tt>x</tt></i>,
--   <i><tt>y</tt></i>
--   
--   <i>Since: 3.0</i>
renderLayout :: (HasCallStack, MonadIO m, IsStyleContext a, IsLayout b) => a -> Context -> Double -> Double -> b -> m ()

-- | Draws a text caret on <i><tt>cr</tt></i> at the specified index of
--   <i><tt>layout</tt></i>.
--   
--   <i>Since: 3.4</i>
renderInsertionCursor :: (HasCallStack, MonadIO m, IsStyleContext a, IsLayout b) => a -> Context -> Double -> Double -> b -> Int32 -> Direction -> m ()

-- | Renders the icon in <i><tt>surface</tt></i> at the specified
--   <i><tt>x</tt></i> and <i><tt>y</tt></i> coordinates.
--   
--   <i>Since: 3.10</i>
renderIconSurface :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Surface -> Double -> Double -> m ()

-- | Renders the icon in <i><tt>pixbuf</tt></i> at the specified
--   <i><tt>x</tt></i> and <i><tt>y</tt></i> coordinates.
--   
--   This function will render the icon in <i><tt>pixbuf</tt></i> at
--   exactly its size, regardless of scaling factors, which may not be
--   appropriate when drawing on displays with high pixel densities.
--   
--   You probably want to use <a>renderIconSurface</a> instead, if you
--   already have a Cairo surface.
--   
--   <i>Since: 3.2</i>
renderIcon :: (HasCallStack, MonadIO m, IsStyleContext a, IsPixbuf b) => a -> Context -> b -> Double -> Double -> m ()

-- | Renders a handle (as in <a>HandleBox</a>, <a>Paned</a> and
--   <a>Window</a>’s resize grip), in the rectangle determined by
--   <i><tt>x</tt></i>, <i><tt>y</tt></i>, <i><tt>width</tt></i>,
--   <i><tt>height</tt></i>.
--   
--   Handles rendered for the paned and grip classes:
--   
--   
--   <i>Since: 3.0</i>
renderHandle :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders a frame around the rectangle defined by (<i><tt>x</tt></i>,
--   <i><tt>y</tt></i>, <i><tt>width</tt></i>, <i><tt>height</tt></i>),
--   leaving a gap on one side. <i><tt>xy0Gap</tt></i> and
--   <i><tt>xy1Gap</tt></i> will mean X coordinates for
--   <a>PositionTypeTop</a> and <a>PositionTypeBottom</a> gap sides, and Y
--   coordinates for <a>PositionTypeLeft</a> and <a>PositionTypeRight</a>.
--   
--   Typical rendering of a frame with a gap:
--   
--   
--   <i>Since: 3.0</i>
renderFrameGap :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> PositionType -> Double -> Double -> m ()

-- | Renders a focus indicator on the rectangle determined by
--   <i><tt>x</tt></i>, <i><tt>y</tt></i>, <i><tt>width</tt></i>,
--   <i><tt>height</tt></i>.
--   
--   Typical focus rendering:
--   
--   
--   <i>Since: 3.0</i>
renderFocus :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders a extension (as in a <a>Notebook</a> tab) in the rectangle
--   defined by <i><tt>x</tt></i>, <i><tt>y</tt></i>,
--   <i><tt>width</tt></i>, <i><tt>height</tt></i>. The side where the
--   extension connects to is defined by <i><tt>gapSide</tt></i>.
--   
--   Typical extension rendering:
--   
--   
--   <i>Since: 3.0</i>
renderExtension :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> PositionType -> m ()

-- | Renders an expander (as used in <a>TreeView</a> and <a>Expander</a>)
--   in the area defined by <i><tt>x</tt></i>, <i><tt>y</tt></i>,
--   <i><tt>width</tt></i>, <i><tt>height</tt></i>. The state
--   <a>StateFlagsChecked</a> determines whether the expander is collapsed
--   or expanded.
--   
--   Typical expander rendering:
--   
--   
--   <i>Since: 3.0</i>
renderExpander :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders a checkmark (as in a <a>CheckButton</a>).
--   
--   The <a>StateFlagsChecked</a> state determines whether the check is on
--   or off, and <a>StateFlagsInconsistent</a> determines whether it should
--   be marked as undefined.
--   
--   Typical checkmark rendering:
--   
--   
--   <i>Since: 3.0</i>
renderCheck :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Returns the area that will be affected (i.e. drawn to) when calling
--   <a>renderBackground</a> for the given <i><tt>context</tt></i> and
--   rectangle.
--   
--   <i>Since: 3.20</i>
renderBackgroundGetClip :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Double -> Double -> Double -> Double -> m Rectangle

-- | Renders an arrow pointing to <i><tt>angle</tt></i>.
--   
--   Typical arrow rendering at 0, 1⁄2 π;, π; and 3⁄2 π:
--   
--   
--   <i>Since: 3.0</i>
renderArrow :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders an activity indicator (such as in <a>Spinner</a>). The state
--   <a>StateFlagsChecked</a> determines whether there is activity going
--   on.
--   
--   <i>Since: 3.0</i>
renderActivity :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Sets the list of files that GTK+ will read at the end of <a>init</a>.
rcSetDefaultFiles :: (HasCallStack, MonadIO m) => [[Char]] -> m ()

-- | This function recomputes the styles for all widgets that use a
--   particular <a>Settings</a> object. (There is one <a>Settings</a>
--   object per <a>Screen</a>, see <a>settingsGetForScreen</a>); It is
--   useful when some global parameter has changed that affects the
--   appearance of all widgets, because when a widget gets a new style, it
--   will both redraw and recompute any cached information about its
--   appearance. As an example, it is used when the default font size set
--   by the operating system changes. Note that this function doesn’t
--   affect widgets that have a style set explicitly on them with
--   <a>widgetSetStyle</a>.
--   
--   <i>Since: 2.4</i>
rcResetStyles :: (HasCallStack, MonadIO m, IsSettings a) => a -> m ()

-- | If the modification time on any previously read file for the given
--   <a>Settings</a> has changed, discard all style information and then
--   reread all previously read RC files.
rcReparseAllForSettings :: (HasCallStack, MonadIO m, IsSettings a) => a -> Bool -> m Bool

-- | If the modification time on any previously read file for the default
--   <a>Settings</a> has changed, discard all style information and then
--   reread all previously read RC files.
rcReparseAll :: (HasCallStack, MonadIO m) => m Bool

-- | Parses resource information directly from a string.
rcParseString :: (HasCallStack, MonadIO m) => Text -> m ()

-- | Parses a <a>StateType</a> variable from the format expected in a RC
--   file.
rcParseState :: (HasCallStack, MonadIO m) => Scanner -> m (Word32, StateType)

-- | Parses a <a>PathPriorityType</a> variable from the format expected in
--   a RC file.
rcParsePriority :: (HasCallStack, MonadIO m) => Scanner -> PathPriorityType -> m Word32

-- | Parses a color in the format expected in a RC file. If
--   <i><tt>style</tt></i> is not <a>Nothing</a>, it will be consulted to
--   resolve references to symbolic colors.
--   
--   <i>Since: 2.12</i>
rcParseColorFull :: (HasCallStack, MonadIO m, IsRcStyle a) => Scanner -> Maybe a -> m (Word32, Color)

-- | Parses a color in the format expected in a RC file.
--   
--   Note that theme engines should use <a>rcParseColorFull</a> in order to
--   support symbolic colors.
rcParseColor :: (HasCallStack, MonadIO m) => Scanner -> m (Word32, Color)

-- | Parses a given resource file.
rcParse :: (HasCallStack, MonadIO m) => Text -> m ()

-- | Returns the standard directory in which themes should be installed.
--   (GTK+ does not actually use this directory itself.)
rcGetThemeDir :: (HasCallStack, MonadIO m) => m Text

-- | Creates up a <a>Style</a> from styles defined in a RC file by
--   providing the raw components used in matching. This function may be
--   useful when creating pseudo-widgets that should be themed like widgets
--   but don’t actually have corresponding GTK+ widgets. An example of this
--   would be items inside a GNOME canvas widget.
--   
--   The action of <a>rcGetStyle</a> is similar to:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   gtk_widget_path (widget, NULL, &amp;path, NULL);
--   gtk_widget_class_path (widget, NULL, &amp;class_path, NULL);
--   gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget),
--                              path, class_path,
--                              G_OBJECT_TYPE (widget));
--   </pre>
rcGetStyleByPaths :: (HasCallStack, MonadIO m, IsSettings a) => a -> Maybe Text -> Maybe Text -> GType -> m (Maybe Style)

-- | Finds all matching RC styles for a given widget, composites them
--   together, and then creates a <a>Style</a> representing the composite
--   appearance. (GTK+ actually keeps a cache of previously created styles,
--   so a new style may not be created.)
rcGetStyle :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Style

-- | Returns a directory in which GTK+ looks for theme engines. For full
--   information about the search for theme engines, see the docs for
--   <tt>GTK_PATH</tt> in [Running GTK+ Applications][gtk-running].
rcGetModuleDir :: (HasCallStack, MonadIO m) => m [Char]

-- | Obtains the path in which to look for IM modules. See the
--   documentation of the <tt>GTK_PATH</tt> environment variable for more
--   details about looking up modules. This function is useful solely for
--   utilities supplied with GTK+ and should not be used by applications
--   under normal circumstances.
rcGetImModulePath :: (HasCallStack, MonadIO m) => m [Char]

-- | Obtains the path to the IM modules file. See the documentation of the
--   <tt>GTK_IM_MODULE_FILE</tt> environment variable for more details.
rcGetImModuleFile :: (HasCallStack, MonadIO m) => m [Char]

-- | Retrieves the current list of RC files that will be parsed at the end
--   of <a>init</a>.
rcGetDefaultFiles :: (HasCallStack, MonadIO m) => m [[Char]]

-- | Looks up a file in pixmap path for the specified <a>Settings</a>. If
--   the file is not found, it outputs a warning message using
--   <tt><i>g_warning()</i></tt> and returns <a>Nothing</a>.
rcFindPixmapInPath :: (HasCallStack, MonadIO m, IsSettings a) => a -> Scanner -> Text -> m [Char]

-- | Searches for a theme engine in the GTK+ search path. This function is
--   not useful for applications and should not be used.
rcFindModuleInPath :: (HasCallStack, MonadIO m) => Text -> m [Char]

-- | Adds a file to the list of files to be parsed at the end of
--   <a>init</a>.
rcAddDefaultFile :: (HasCallStack, MonadIO m) => [Char] -> m ()

-- | Sends an event to a widget, propagating the event to parent widgets if
--   the event remains unhandled.
--   
--   Events received by GTK+ from GDK normally begin in <a>mainDoEvent</a>.
--   Depending on the type of event, existence of modal dialogs, grabs,
--   etc., the event may be propagated; if so, this function is used.
--   
--   <a>propagateEvent</a> calls <a>widgetEvent</a> on each widget it
--   decides to send the event to. So <a>widgetEvent</a> is the
--   lowest-level function; it simply emits the <a>Widget::event</a> and
--   possibly an event-specific signal on a widget. <a>propagateEvent</a>
--   is a bit higher-level, and <a>mainDoEvent</a> is the highest level.
--   
--   All that said, you most likely don’t want to use any of these
--   functions; synthesizing events is rarely needed. There are almost
--   certainly better ways to achieve your goals. For example, use
--   <a>windowInvalidateRect</a> or <a>widgetQueueDraw</a> instead of
--   making up expose events.
propagateEvent :: (HasCallStack, MonadIO m, IsWidget a) => a -> Event -> m ()

-- | Runs a page setup dialog, letting the user modify the values from
--   <i><tt>pageSetup</tt></i>. If the user cancels the dialog, the
--   returned <a>PageSetup</a> is identical to the passed in
--   <i><tt>pageSetup</tt></i>, otherwise it contains the modifications
--   done in the dialog.
--   
--   Note that this function may use a recursive mainloop to show the page
--   setup dialog. See <a>printRunPageSetupDialogAsync</a> if this is a
--   problem.
--   
--   <i>Since: 2.10</i>
printRunPageSetupDialog :: (HasCallStack, MonadIO m, IsWindow a, IsPageSetup b, IsPrintSettings c) => Maybe a -> Maybe b -> c -> m PageSetup

-- | Draws a vertical line from (<i><tt>x</tt></i>, <i><tt>y1_</tt></i>) to
--   (<i><tt>x</tt></i>, <i><tt>y2_</tt></i>) in <i><tt>cr</tt></i> using
--   the given style and state.
paintVline :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> m ()

-- | Draws an option menu tab (i.e. the up and down pointing arrows) in the
--   given rectangle on <i><tt>cr</tt></i> using the given parameters.
paintTab :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Draws a spinner on <i><tt>window</tt></i> using the given parameters.
paintSpinner :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe b -> Maybe Text -> Word32 -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Draws a slider in the given rectangle on <i><tt>cr</tt></i> using the
--   given style and orientation.
paintSlider :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> Orientation -> m ()

-- | Draws a shadow around the given rectangle in <i><tt>cr</tt></i> using
--   the given style and state and shadow type, leaving a gap in one side.
paintShadowGap :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> PositionType -> Int32 -> Int32 -> m ()

-- | Draws a shadow around the given rectangle in <i><tt>cr</tt></i> using
--   the given style and state and shadow type.
paintShadow :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Draws a resize grip in the given rectangle on <i><tt>cr</tt></i> using
--   the given parameters.
paintResizeGrip :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe b -> Maybe Text -> WindowEdge -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Draws a radio button indicator in the given rectangle on
--   <i><tt>cr</tt></i> with the given parameters.
paintOption :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Draws a layout on <i><tt>cr</tt></i> using the given parameters.
paintLayout :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b, IsLayout c) => a -> Context -> StateType -> Bool -> Maybe b -> Maybe Text -> Int32 -> Int32 -> c -> m ()

-- | Draws a horizontal line from (<i><tt>x1</tt></i>, <i><tt>y</tt></i>)
--   to (<i><tt>x2</tt></i>, <i><tt>y</tt></i>) in <i><tt>cr</tt></i> using
--   the given style and state.
paintHline :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> m ()

-- | Draws a handle as used in <a>HandleBox</a> and <a>Paned</a>.
paintHandle :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> Orientation -> m ()

-- | Draws a focus indicator around the given rectangle on
--   <i><tt>cr</tt></i> using the given style.
paintFocus :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Draws a flat box on <i><tt>cr</tt></i> with the given parameters.
paintFlatBox :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Draws an extension, i.e. a notebook tab.
paintExtension :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> PositionType -> m ()

-- | Draws an expander as used in <a>TreeView</a>. <i><tt>x</tt></i> and
--   <i><tt>y</tt></i> specify the center the expander. The size of the
--   expander is determined by the “expander-size” style property of
--   <i><tt>widget</tt></i>. (If widget is not specified or doesn’t have an
--   “expander-size” property, an unspecified default size will be used,
--   since the caller doesn't have sufficient information to position the
--   expander, this is likely not useful.) The expander is expander_size
--   pixels tall in the collapsed position and expander_size pixels wide in
--   the expanded position.
paintExpander :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> ExpanderStyle -> m ()

-- | Draws a diamond in the given rectangle on <i><tt>window</tt></i> using
--   the given parameters.
paintDiamond :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Draws a check button indicator in the given rectangle on
--   <i><tt>cr</tt></i> with the given parameters.
paintCheck :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Draws a box in <i><tt>cr</tt></i> using the given style and state and
--   shadow type, leaving a gap in one side.
paintBoxGap :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> PositionType -> Int32 -> Int32 -> m ()

-- | Draws a box on <i><tt>cr</tt></i> with the given parameters.
paintBox :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Draws an arrow in the given rectangle on <i><tt>cr</tt></i> using the
--   given parameters. <i><tt>arrowType</tt></i> determines the direction
--   of the arrow.
paintArrow :: (HasCallStack, MonadIO m, IsStyle a, IsWidget b) => a -> Context -> StateType -> ShadowType -> Maybe b -> Maybe Text -> ArrowType -> Bool -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Makes the innermost invocation of the main loop return when it regains
--   control.
mainQuit :: (HasCallStack, MonadIO m) => m ()

-- | Asks for the current nesting level of the main loop.
mainLevel :: (HasCallStack, MonadIO m) => m Word32

-- | Runs a single iteration of the mainloop. If no events are available
--   either return or block depending on the value of
--   <i><tt>blocking</tt></i>.
mainIterationDo :: (HasCallStack, MonadIO m) => Bool -> m Bool

-- | Runs a single iteration of the mainloop.
--   
--   If no events are waiting to be processed GTK+ will block until the
--   next event is noticed. If you don’t want to block look at
--   <a>mainIterationDo</a> or check if any events are pending with
--   <a>eventsPending</a> first.
mainIteration :: (HasCallStack, MonadIO m) => m Bool

-- | Removes the key snooper function with the given id.
keySnooperRemove :: (HasCallStack, MonadIO m) => Word32 -> m ()

-- | This function does the same work as <a>initCheck</a>. Additionally, it
--   allows you to add your own commandline options, and it automatically
--   generates nicely formatted <tt>--help</tt> output. Note that your
--   program will be terminated after writing out the help output.
--   
--   <i>Since: 2.6</i>
initWithArgs :: (HasCallStack, MonadIO m) => Maybe [Text] -> Maybe Text -> [OptionEntry] -> Maybe Text -> m (Maybe [Text])

-- | Queries the current grab of the default window group.
grabGetCurrent :: (HasCallStack, MonadIO m) => m (Maybe Widget)

-- | Returns a <a>OptionGroup</a> for the commandline arguments recognized
--   by GTK+ and GDK.
--   
--   You should add this group to your <a>OptionContext</a> with
--   <a>optionContextAddGroup</a>, if you are using
--   <a>optionContextParse</a> to parse your commandline arguments.
--   
--   <i>Since: 2.6</i>
getOptionGroup :: (HasCallStack, MonadIO m) => Bool -> m OptionGroup

-- | Get the direction of the current locale. This is the expected reading
--   direction for text and UI.
--   
--   This function depends on the current locale being set with
--   <tt><i>setlocale()</i></tt> and will default to setting the
--   <a>TextDirectionLtr</a> direction otherwise. <a>TextDirectionNone</a>
--   will never be returned.
--   
--   GTK+ sets the default text direction according to the locale during
--   <a>init</a>, and you should normally use <a>widgetGetDirection</a> or
--   <a>widgetGetDefaultDirection</a> to obtain the current direcion.
--   
--   This function is only needed rare cases when the locale is changed
--   after GTK+ has already been initialized. In this case, you can use it
--   to update the default text direction as follows:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   setlocale (LC_ALL, new_locale);
--   direction = gtk_get_locale_direction ();
--   gtk_widget_set_default_direction (direction);
--   </pre>
--   
--   <i>Since: 3.12</i>
getLocaleDirection :: (HasCallStack, MonadIO m) => m TextDirection

-- | If <i><tt>event</tt></i> is <a>Nothing</a> or the event was not
--   associated with any widget, returns <a>Nothing</a>, otherwise returns
--   the widget that received the event originally.
getEventWidget :: (HasCallStack, MonadIO m) => Event -> m (Maybe Widget)

-- | If there is a current event and it has a state field, place that state
--   field in <i><tt>state</tt></i> and return <a>True</a>, otherwise
--   return <a>False</a>.
getCurrentEventState :: (HasCallStack, MonadIO m) => m (Bool, [ModifierType])

-- | If there is a current event and it has a device, return that device,
--   otherwise return <a>Nothing</a>.
getCurrentEventDevice :: (HasCallStack, MonadIO m) => m (Maybe Device)

-- | Obtains a copy of the event currently being processed by GTK+.
--   
--   For example, if you are handling a <a>Button::clicked</a> signal, the
--   current event will be the <a>EventButton</a> that triggered the
--   <a>clicked</a> signal.
getCurrentEvent :: (HasCallStack, MonadIO m) => m (Maybe Event)

-- | Analogical to <a>true</a>, this function does nothing but always
--   returns <a>False</a>.
false :: (HasCallStack, MonadIO m) => m Bool

-- | Draws a text caret on <i><tt>cr</tt></i> at <i><tt>location</tt></i>.
--   This is not a style function but merely a convenience function for
--   drawing the standard cursor shape.
--   
--   <i>Since: 3.0</i>
drawInsertionCursor :: (HasCallStack, MonadIO m, IsWidget a) => a -> Context -> Rectangle -> Bool -> TextDirection -> Bool -> m ()

-- | Changes the icon for drag operation to a given widget. GTK+ will not
--   destroy the widget, so if you don’t want it to persist, you should
--   connect to the “drag-end” signal and destroy it yourself.
dragSetIconWidget :: (HasCallStack, MonadIO m, IsDragContext a, IsWidget b) => a -> b -> Int32 -> Int32 -> m ()

-- | Sets <i><tt>surface</tt></i> as the icon for a given drag. GTK+
--   retains references for the arguments, and will release them when they
--   are no longer needed.
--   
--   To position the surface relative to the mouse, use
--   <tt><i>cairo_surface_set_device_offset()</i></tt> on
--   <i><tt>surface</tt></i>. The mouse cursor will be positioned at the
--   (0,0) coordinate of the surface.
dragSetIconSurface :: (HasCallStack, MonadIO m, IsDragContext a) => a -> Surface -> m ()

-- | Sets the icon for a given drag from a stock ID.
dragSetIconStock :: (HasCallStack, MonadIO m, IsDragContext a) => a -> Text -> Int32 -> Int32 -> m ()

-- | Sets <i><tt>pixbuf</tt></i> as the icon for a given drag.
dragSetIconPixbuf :: (HasCallStack, MonadIO m, IsDragContext a, IsPixbuf b) => a -> b -> Int32 -> Int32 -> m ()

-- | Sets the icon for a given drag from a named themed icon. See the docs
--   for <a>IconTheme</a> for more details. Note that the size of the icon
--   depends on the icon theme (the icon is loaded at the symbolic size
--   <tt><i>GTK_ICON_SIZE_DND</i></tt>), thus <i><tt>hotX</tt></i> and
--   <i><tt>hotY</tt></i> have to be used with care.
--   
--   <i>Since: 2.8</i>
dragSetIconName :: (HasCallStack, MonadIO m, IsDragContext a) => a -> Text -> Int32 -> Int32 -> m ()

-- | Sets the icon for a given drag from the given <i><tt>icon</tt></i>.
--   See the documentation for <a>dragSetIconName</a> for more details
--   about using icons in drag and drop.
--   
--   <i>Since: 3.2</i>
dragSetIconGicon :: (HasCallStack, MonadIO m, IsDragContext a, IsIcon b) => a -> b -> Int32 -> Int32 -> m ()

-- | Sets the icon for a particular drag to the default icon.
dragSetIconDefault :: (HasCallStack, MonadIO m, IsDragContext a) => a -> m ()

-- | Determines the source widget for a drag.
dragGetSourceWidget :: (HasCallStack, MonadIO m, IsDragContext a) => a -> m (Maybe Widget)

-- | Cancels an ongoing drag operation on the source side.
--   
--   If you want to be able to cancel a drag operation in this way, you
--   need to keep a pointer to the drag context, either from an explicit
--   call to <a>widgetDragBeginWithCoordinates</a>, or by connecting to
--   <a>Widget::dragBegin</a>.
--   
--   If <i><tt>context</tt></i> does not refer to an ongoing drag
--   operation, this function does nothing.
--   
--   If a drag is cancelled in this way, the <i><tt>result</tt></i>
--   argument of <a>Widget::dragFailed</a> is set to
--   <i><tt>gTKDRAGRESULTERROR</tt></i>.
--   
--   <i>Since: 3.16</i>
dragCancel :: (HasCallStack, MonadIO m, IsDragContext a) => a -> m ()

-- | Distributes <i><tt>extraSpace</tt></i> to child <i><tt>sizes</tt></i>
--   by bringing smaller children up to natural size first.
--   
--   The remaining space will be added to the <i><tt>minimumSize</tt></i>
--   member of the GtkRequestedSize struct. If all sizes reach their
--   natural size then the remaining space is returned.
distributeNaturalAllocation :: (HasCallStack, MonadIO m) => Int32 -> [RequestedSize] -> m (Int32, [RequestedSize])

-- | Prevents <a>init</a>, <a>initCheck</a>, <a>initWithArgs</a> and
--   <a>parseArgs</a> from automatically calling <tt>setlocale (LC_ALL,
--   "")</tt>. You would want to use this function if you wanted to set the
--   locale for your program to something other than the user’s locale, or
--   if you wanted to set different values for different locale categories.
--   
--   Most programs should not need to call this function.
disableSetlocale :: (HasCallStack, MonadIO m) => m ()

-- | Removes a device grab from the given widget.
--   
--   You have to pair calls to <a>deviceGrabAdd</a> and
--   <a>deviceGrabRemove</a>.
--   
--   <i>Since: 3.0</i>
deviceGrabRemove :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> m ()

-- | Transforms the given cairo context <i><tt>cr</tt></i> that from
--   <i><tt>widget</tt></i>-relative coordinates to
--   <i><tt>window</tt></i>-relative coordinates. If the
--   <i><tt>widget</tt></i>’s window is not an ancestor of
--   <i><tt>window</tt></i>, no modification will be applied.
--   
--   This is the inverse to the transformation GTK applies when preparing
--   an expose event to be emitted with the <a>Widget::draw</a> signal. It
--   is intended to help porting multiwindow widgets from GTK+ 2 to the
--   rendering architecture of GTK+ 3.
--   
--   <i>Since: 3.0</i>
cairoTransformToWindow :: (HasCallStack, MonadIO m, IsWidget a, IsWindow b) => Context -> a -> b -> m ()

-- | This function is supposed to be called in <a>Widget::draw</a>
--   implementations for widgets that support multiple windows.
--   <i><tt>cr</tt></i> must be untransformed from invoking of the draw
--   function. This function will return <a>True</a> if the contents of the
--   given <i><tt>window</tt></i> are supposed to be drawn and <a>False</a>
--   otherwise. Note that when the drawing was not initiated by the
--   windowing system this function will return <a>True</a> for all
--   windows, so you need to draw the bottommost window first. Also, do not
--   use “else if” statements to check which window should be drawn.
--   
--   <i>Since: 3.0</i>
cairoShouldDrawWindow :: (HasCallStack, MonadIO m, IsWindow a) => Context -> a -> m Bool

-- | Looks up key bindings for <i><tt>object</tt></i> to find one matching
--   <i><tt>event</tt></i>, and if one was found, activate it.
--   
--   <i>Since: 2.4</i>
bindingsActivateEvent :: (HasCallStack, MonadIO m, IsObject a) => a -> EventKey -> m Bool

-- | Find a key binding matching <i><tt>keyval</tt></i> and
--   <i><tt>modifiers</tt></i> and activate the binding on
--   <i><tt>object</tt></i>.
bindingsActivate :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> [ModifierType] -> m Bool

-- | Returns <a>True</a> if dialogs are expected to use an alternative
--   button order on the screen <i><tt>screen</tt></i>. See
--   <tt><i>gtk_dialog_set_alternative_button_order()</i></tt> for more
--   details about alternative button order.
--   
--   If you need to use this function, you should probably connect to the
--   <a>notify</a>:gtk-alternative-button-order signal on the
--   <a>Settings</a> object associated to <i><tt>screen</tt></i>, in order
--   to be notified if the button order setting changes.
--   
--   <i>Since: 2.6</i>
alternativeDialogButtonOrder :: (HasCallStack, MonadIO m, IsScreen a) => Maybe a -> m Bool

-- | Determines whether a given keyval and modifier mask constitute a valid
--   keyboard accelerator. For example, the <a>KEY_a</a> keyval plus
--   <tt><i>GDK_CONTROL_MASK</i></tt> is valid - this is a “Ctrl+a”
--   accelerator. But, you can't, for instance, use the
--   <a>KEY_Control_L</a> keyval as an accelerator.
acceleratorValid :: (HasCallStack, MonadIO m) => Word32 -> [ModifierType] -> m Bool

-- | Sets the modifiers that will be considered significant for keyboard
--   accelerators. The default mod mask depends on the GDK backend in use,
--   but will typically include <tt><i>GDK_CONTROL_MASK</i></tt> |
--   <tt><i>GDK_SHIFT_MASK</i></tt> | <tt><i>GDK_MOD1_MASK</i></tt> |
--   <tt><i>GDK_SUPER_MASK</i></tt> | <tt><i>GDK_HYPER_MASK</i></tt> |
--   <tt><i>GDK_META_MASK</i></tt>. In other words, Control, Shift, Alt,
--   Super, Hyper and Meta. Other modifiers will by default be ignored by
--   <a>AccelGroup</a>.
--   
--   You must include at least the three modifiers Control, Shift and Alt
--   in any value you pass to this function.
--   
--   The default mod mask should be changed on application startup, before
--   using any accelerator groups.
acceleratorSetDefaultModMask :: (HasCallStack, MonadIO m) => [ModifierType] -> m ()

-- | Parses a string representing an accelerator, similarly to
--   <a>acceleratorParse</a> but handles keycodes as well. This is only
--   useful for system-level components, applications should use
--   <a>acceleratorParse</a> instead.
--   
--   If <i><tt>acceleratorCodes</tt></i> is given and the result stored in
--   it is non-<a>Nothing</a>, the result must be freed with <a>free</a>.
--   
--   If a keycode is present in the accelerator and no
--   <i><tt>acceleratorCodes</tt></i> is given, the parse will fail.
--   
--   If the parse fails, <i><tt>acceleratorKey</tt></i>,
--   <i><tt>acceleratorMods</tt></i> and <i><tt>acceleratorCodes</tt></i>
--   will be set to 0 (zero).
--   
--   <i>Since: 3.4</i>
acceleratorParseWithKeycode :: (HasCallStack, MonadIO m) => Text -> m (Word32, [Word32], [ModifierType])

-- | Converts an accelerator keyval and modifier mask into a string
--   parseable by <a>acceleratorParseWithKeycode</a>, similarly to
--   <a>acceleratorName</a> but handling keycodes. This is only useful for
--   system-level components, applications should use
--   <a>acceleratorParse</a> instead.
--   
--   <i>Since: 3.4</i>
acceleratorNameWithKeycode :: (HasCallStack, MonadIO m, IsDisplay a) => Maybe a -> Word32 -> Word32 -> [ModifierType] -> m Text

-- | Converts an accelerator keyval and modifier mask into a string
--   parseable by <a>acceleratorParse</a>. For example, if you pass in
--   <a>KEY_q</a> and <tt><i>GDK_CONTROL_MASK</i></tt>, this function
--   returns “&lt;Control&gt;q”.
--   
--   If you need to display accelerators in the user interface, see
--   <a>acceleratorGetLabel</a>.
acceleratorName :: (HasCallStack, MonadIO m) => Word32 -> [ModifierType] -> m Text

-- | Converts an accelerator keyval and modifier mask into a (possibly
--   translated) string that can be displayed to a user, similarly to
--   <a>acceleratorGetLabel</a>, but handling keycodes.
--   
--   This is only useful for system-level components, applications should
--   use <a>acceleratorParse</a> instead.
--   
--   <i>Since: 3.4</i>
acceleratorGetLabelWithKeycode :: (HasCallStack, MonadIO m, IsDisplay a) => Maybe a -> Word32 -> Word32 -> [ModifierType] -> m Text

-- | Converts an accelerator keyval and modifier mask into a string which
--   can be used to represent the accelerator to the user.
--   
--   <i>Since: 2.6</i>
acceleratorGetLabel :: (HasCallStack, MonadIO m) => Word32 -> [ModifierType] -> m Text

-- | Gets the modifier mask.
--   
--   The modifier mask determines which modifiers are considered
--   significant for keyboard accelerators. See
--   <a>acceleratorSetDefaultModMask</a>.
acceleratorGetDefaultModMask :: (HasCallStack, MonadIO m) => m [ModifierType]

-- | Gets a list of all accel groups which are attached to
--   <i><tt>object</tt></i>.
accelGroupsFromObject :: (HasCallStack, MonadIO m, IsObject a) => a -> m [AccelGroup]
calendarDay :: AttrLabelProxy "day"
calendarMonth :: AttrLabelProxy "month"
calendarYear :: AttrLabelProxy "year"
actionableActionName :: AttrLabelProxy "actionName"
actionableActionTarget :: AttrLabelProxy "actionTarget"
activatableRelatedAction :: AttrLabelProxy "relatedAction"
activatableUseActionAppearance :: AttrLabelProxy "useActionAppearance"
appChooserContentType :: AttrLabelProxy "contentType"
cellEditableEditingCanceled :: AttrLabelProxy "editingCanceled"
colorChooserRgba :: AttrLabelProxy "rgba"
colorChooserUseAlpha :: AttrLabelProxy "useAlpha"
fileChooserAction :: AttrLabelProxy "action"
fileChooserCreateFolders :: AttrLabelProxy "createFolders"
fileChooserDoOverwriteConfirmation :: AttrLabelProxy "doOverwriteConfirmation"
fileChooserExtraWidget :: AttrLabelProxy "extraWidget"
fileChooserFilter :: AttrLabelProxy "filter"
fileChooserLocalOnly :: AttrLabelProxy "localOnly"
fileChooserPreviewWidget :: AttrLabelProxy "previewWidget"
fileChooserPreviewWidgetActive :: AttrLabelProxy "previewWidgetActive"
fileChooserSelectMultiple :: AttrLabelProxy "selectMultiple"
fileChooserShowHidden :: AttrLabelProxy "showHidden"
fileChooserUsePreviewLabel :: AttrLabelProxy "usePreviewLabel"
fontChooserFont :: AttrLabelProxy "font"
fontChooserFontDesc :: AttrLabelProxy "fontDesc"
fontChooserFontFeatures :: AttrLabelProxy "fontFeatures"
fontChooserLanguage :: AttrLabelProxy "language"
fontChooserLevel :: AttrLabelProxy "level"
fontChooserPreviewText :: AttrLabelProxy "previewText"
fontChooserShowPreviewEntry :: AttrLabelProxy "showPreviewEntry"
orientableOrientation :: AttrLabelProxy "orientation"
recentChooserFilter :: AttrLabelProxy "filter"
recentChooserLimit :: AttrLabelProxy "limit"
recentChooserLocalOnly :: AttrLabelProxy "localOnly"
recentChooserRecentManager :: AttrLabelProxy "recentManager"
recentChooserSelectMultiple :: AttrLabelProxy "selectMultiple"
recentChooserShowIcons :: AttrLabelProxy "showIcons"
recentChooserShowNotFound :: AttrLabelProxy "showNotFound"
recentChooserShowPrivate :: AttrLabelProxy "showPrivate"
recentChooserShowTips :: AttrLabelProxy "showTips"
recentChooserSortType :: AttrLabelProxy "sortType"
scrollableHadjustment :: AttrLabelProxy "hadjustment"
scrollableHscrollPolicy :: AttrLabelProxy "hscrollPolicy"
scrollableVadjustment :: AttrLabelProxy "vadjustment"
scrollableVscrollPolicy :: AttrLabelProxy "vscrollPolicy"
aboutDialogArtists :: AttrLabelProxy "artists"
aboutDialogAuthors :: AttrLabelProxy "authors"
aboutDialogComments :: AttrLabelProxy "comments"
aboutDialogCopyright :: AttrLabelProxy "copyright"
aboutDialogDocumenters :: AttrLabelProxy "documenters"
aboutDialogLicense :: AttrLabelProxy "license"
aboutDialogLicenseType :: AttrLabelProxy "licenseType"
aboutDialogLogo :: AttrLabelProxy "logo"
aboutDialogLogoIconName :: AttrLabelProxy "logoIconName"
aboutDialogProgramName :: AttrLabelProxy "programName"
aboutDialogTranslatorCredits :: AttrLabelProxy "translatorCredits"
aboutDialogVersion :: AttrLabelProxy "version"
aboutDialogWebsite :: AttrLabelProxy "website"
aboutDialogWebsiteLabel :: AttrLabelProxy "websiteLabel"
aboutDialogWrapLicense :: AttrLabelProxy "wrapLicense"
accelGroupIsLocked :: AttrLabelProxy "isLocked"
accelGroupModifierMask :: AttrLabelProxy "modifierMask"
accelLabelAccelClosure :: AttrLabelProxy "accelClosure"
accelLabelAccelWidget :: AttrLabelProxy "accelWidget"
accessibleWidget :: AttrLabelProxy "widget"
actionActionGroup :: AttrLabelProxy "actionGroup"
actionAlwaysShowImage :: AttrLabelProxy "alwaysShowImage"
actionGicon :: AttrLabelProxy "gicon"
actionHideIfEmpty :: AttrLabelProxy "hideIfEmpty"
actionIconName :: AttrLabelProxy "iconName"
actionIsImportant :: AttrLabelProxy "isImportant"
actionLabel :: AttrLabelProxy "label"
actionName :: AttrLabelProxy "name"
actionSensitive :: AttrLabelProxy "sensitive"
actionShortLabel :: AttrLabelProxy "shortLabel"
actionStockId :: AttrLabelProxy "stockId"
actionTooltip :: AttrLabelProxy "tooltip"
actionVisible :: AttrLabelProxy "visible"
actionVisibleHorizontal :: AttrLabelProxy "visibleHorizontal"
actionVisibleOverflown :: AttrLabelProxy "visibleOverflown"
actionVisibleVertical :: AttrLabelProxy "visibleVertical"
actionGroupAccelGroup :: AttrLabelProxy "accelGroup"
actionGroupName :: AttrLabelProxy "name"
actionGroupSensitive :: AttrLabelProxy "sensitive"
actionGroupVisible :: AttrLabelProxy "visible"
adjustmentLower :: AttrLabelProxy "lower"
adjustmentPageIncrement :: AttrLabelProxy "pageIncrement"
adjustmentPageSize :: AttrLabelProxy "pageSize"
adjustmentStepIncrement :: AttrLabelProxy "stepIncrement"
adjustmentUpper :: AttrLabelProxy "upper"
adjustmentValue :: AttrLabelProxy "value"
alignmentBottomPadding :: AttrLabelProxy "bottomPadding"
alignmentLeftPadding :: AttrLabelProxy "leftPadding"
alignmentRightPadding :: AttrLabelProxy "rightPadding"
alignmentTopPadding :: AttrLabelProxy "topPadding"
alignmentXalign :: AttrLabelProxy "xalign"
alignmentXscale :: AttrLabelProxy "xscale"
alignmentYalign :: AttrLabelProxy "yalign"
alignmentYscale :: AttrLabelProxy "yscale"
appChooserButtonHeading :: AttrLabelProxy "heading"
appChooserButtonShowDefaultItem :: AttrLabelProxy "showDefaultItem"
appChooserButtonShowDialogItem :: AttrLabelProxy "showDialogItem"
appChooserDialogGfile :: AttrLabelProxy "gfile"
appChooserDialogHeading :: AttrLabelProxy "heading"
appChooserWidgetDefaultText :: AttrLabelProxy "defaultText"
appChooserWidgetShowAll :: AttrLabelProxy "showAll"
appChooserWidgetShowDefault :: AttrLabelProxy "showDefault"
appChooserWidgetShowFallback :: AttrLabelProxy "showFallback"
appChooserWidgetShowOther :: AttrLabelProxy "showOther"
appChooserWidgetShowRecommended :: AttrLabelProxy "showRecommended"
applicationActiveWindow :: AttrLabelProxy "activeWindow"
applicationAppMenu :: AttrLabelProxy "appMenu"
applicationMenubar :: AttrLabelProxy "menubar"
applicationRegisterSession :: AttrLabelProxy "registerSession"
applicationScreensaverActive :: AttrLabelProxy "screensaverActive"
applicationWindowShowMenubar :: AttrLabelProxy "showMenubar"
arrowArrowType :: AttrLabelProxy "arrowType"
arrowShadowType :: AttrLabelProxy "shadowType"
aspectFrameObeyChild :: AttrLabelProxy "obeyChild"
aspectFrameRatio :: AttrLabelProxy "ratio"
aspectFrameXalign :: AttrLabelProxy "xalign"
aspectFrameYalign :: AttrLabelProxy "yalign"
assistantUseHeaderBar :: AttrLabelProxy "useHeaderBar"
boxBaselinePosition :: AttrLabelProxy "baselinePosition"
boxHomogeneous :: AttrLabelProxy "homogeneous"
boxSpacing :: AttrLabelProxy "spacing"
builderTranslationDomain :: AttrLabelProxy "translationDomain"
buttonAlwaysShowImage :: AttrLabelProxy "alwaysShowImage"
buttonImage :: AttrLabelProxy "image"
buttonImagePosition :: AttrLabelProxy "imagePosition"
buttonLabel :: AttrLabelProxy "label"
buttonRelief :: AttrLabelProxy "relief"
buttonUseStock :: AttrLabelProxy "useStock"
buttonUseUnderline :: AttrLabelProxy "useUnderline"
buttonXalign :: AttrLabelProxy "xalign"
buttonYalign :: AttrLabelProxy "yalign"
buttonBoxLayoutStyle :: AttrLabelProxy "layoutStyle"
calendarDetailHeightRows :: AttrLabelProxy "detailHeightRows"
calendarDetailWidthChars :: AttrLabelProxy "detailWidthChars"
calendarNoMonthChange :: AttrLabelProxy "noMonthChange"
calendarShowDayNames :: AttrLabelProxy "showDayNames"
calendarShowDetails :: AttrLabelProxy "showDetails"
calendarShowHeading :: AttrLabelProxy "showHeading"
calendarShowWeekNumbers :: AttrLabelProxy "showWeekNumbers"
cellAreaEditWidget :: AttrLabelProxy "editWidget"
cellAreaEditedCell :: AttrLabelProxy "editedCell"
cellAreaFocusCell :: AttrLabelProxy "focusCell"
cellAreaBoxSpacing :: AttrLabelProxy "spacing"
cellAreaContextArea :: AttrLabelProxy "area"
cellAreaContextMinimumHeight :: AttrLabelProxy "minimumHeight"
cellAreaContextMinimumWidth :: AttrLabelProxy "minimumWidth"
cellAreaContextNaturalHeight :: AttrLabelProxy "naturalHeight"
cellAreaContextNaturalWidth :: AttrLabelProxy "naturalWidth"
cellRendererCellBackground :: AttrLabelProxy "cellBackground"
cellRendererCellBackgroundGdk :: AttrLabelProxy "cellBackgroundGdk"
cellRendererCellBackgroundRgba :: AttrLabelProxy "cellBackgroundRgba"
cellRendererCellBackgroundSet :: AttrLabelProxy "cellBackgroundSet"
cellRendererEditing :: AttrLabelProxy "editing"
cellRendererHeight :: AttrLabelProxy "height"
cellRendererIsExpanded :: AttrLabelProxy "isExpanded"
cellRendererIsExpander :: AttrLabelProxy "isExpander"
cellRendererMode :: AttrLabelProxy "mode"
cellRendererSensitive :: AttrLabelProxy "sensitive"
cellRendererVisible :: AttrLabelProxy "visible"
cellRendererWidth :: AttrLabelProxy "width"
cellRendererXalign :: AttrLabelProxy "xalign"
cellRendererXpad :: AttrLabelProxy "xpad"
cellRendererYalign :: AttrLabelProxy "yalign"
cellRendererYpad :: AttrLabelProxy "ypad"
cellRendererAccelAccelKey :: AttrLabelProxy "accelKey"
cellRendererAccelAccelMode :: AttrLabelProxy "accelMode"
cellRendererAccelAccelMods :: AttrLabelProxy "accelMods"
cellRendererAccelKeycode :: AttrLabelProxy "keycode"
cellRendererComboHasEntry :: AttrLabelProxy "hasEntry"
cellRendererComboModel :: AttrLabelProxy "model"
cellRendererComboTextColumn :: AttrLabelProxy "textColumn"
cellRendererPixbufFollowState :: AttrLabelProxy "followState"
cellRendererPixbufGicon :: AttrLabelProxy "gicon"
cellRendererPixbufIconName :: AttrLabelProxy "iconName"
cellRendererPixbufPixbuf :: AttrLabelProxy "pixbuf"
cellRendererPixbufPixbufExpanderClosed :: AttrLabelProxy "pixbufExpanderClosed"
cellRendererPixbufPixbufExpanderOpen :: AttrLabelProxy "pixbufExpanderOpen"
cellRendererPixbufStockDetail :: AttrLabelProxy "stockDetail"
cellRendererPixbufStockId :: AttrLabelProxy "stockId"
cellRendererPixbufStockSize :: AttrLabelProxy "stockSize"
cellRendererPixbufSurface :: AttrLabelProxy "surface"
cellRendererProgressInverted :: AttrLabelProxy "inverted"
cellRendererProgressPulse :: AttrLabelProxy "pulse"
cellRendererProgressText :: AttrLabelProxy "text"
cellRendererProgressTextXalign :: AttrLabelProxy "textXalign"
cellRendererProgressTextYalign :: AttrLabelProxy "textYalign"
cellRendererProgressValue :: AttrLabelProxy "value"
cellRendererSpinAdjustment :: AttrLabelProxy "adjustment"
cellRendererSpinClimbRate :: AttrLabelProxy "climbRate"
cellRendererSpinDigits :: AttrLabelProxy "digits"
cellRendererSpinnerActive :: AttrLabelProxy "active"
cellRendererSpinnerPulse :: AttrLabelProxy "pulse"
cellRendererSpinnerSize :: AttrLabelProxy "size"
cellRendererTextAlignSet :: AttrLabelProxy "alignSet"
cellRendererTextAlignment :: AttrLabelProxy "alignment"
cellRendererTextAttributes :: AttrLabelProxy "attributes"
cellRendererTextBackground :: AttrLabelProxy "background"
cellRendererTextBackgroundGdk :: AttrLabelProxy "backgroundGdk"
cellRendererTextBackgroundRgba :: AttrLabelProxy "backgroundRgba"
cellRendererTextBackgroundSet :: AttrLabelProxy "backgroundSet"
cellRendererTextEditable :: AttrLabelProxy "editable"
cellRendererTextEditableSet :: AttrLabelProxy "editableSet"
cellRendererTextEllipsize :: AttrLabelProxy "ellipsize"
cellRendererTextEllipsizeSet :: AttrLabelProxy "ellipsizeSet"
cellRendererTextFamily :: AttrLabelProxy "family"
cellRendererTextFamilySet :: AttrLabelProxy "familySet"
cellRendererTextFont :: AttrLabelProxy "font"
cellRendererTextFontDesc :: AttrLabelProxy "fontDesc"
cellRendererTextForeground :: AttrLabelProxy "foreground"
cellRendererTextForegroundGdk :: AttrLabelProxy "foregroundGdk"
cellRendererTextForegroundRgba :: AttrLabelProxy "foregroundRgba"
cellRendererTextForegroundSet :: AttrLabelProxy "foregroundSet"
cellRendererTextLanguage :: AttrLabelProxy "language"
cellRendererTextLanguageSet :: AttrLabelProxy "languageSet"
cellRendererTextMarkup :: AttrLabelProxy "markup"
cellRendererTextMaxWidthChars :: AttrLabelProxy "maxWidthChars"
cellRendererTextPlaceholderText :: AttrLabelProxy "placeholderText"
cellRendererTextRise :: AttrLabelProxy "rise"
cellRendererTextRiseSet :: AttrLabelProxy "riseSet"
cellRendererTextScale :: AttrLabelProxy "scale"
cellRendererTextScaleSet :: AttrLabelProxy "scaleSet"
cellRendererTextSingleParagraphMode :: AttrLabelProxy "singleParagraphMode"
cellRendererTextSize :: AttrLabelProxy "size"
cellRendererTextSizePoints :: AttrLabelProxy "sizePoints"
cellRendererTextSizeSet :: AttrLabelProxy "sizeSet"
cellRendererTextStretch :: AttrLabelProxy "stretch"
cellRendererTextStretchSet :: AttrLabelProxy "stretchSet"
cellRendererTextStrikethrough :: AttrLabelProxy "strikethrough"
cellRendererTextStrikethroughSet :: AttrLabelProxy "strikethroughSet"
cellRendererTextStyle :: AttrLabelProxy "style"
cellRendererTextStyleSet :: AttrLabelProxy "styleSet"
cellRendererTextText :: AttrLabelProxy "text"
cellRendererTextUnderline :: AttrLabelProxy "underline"
cellRendererTextUnderlineSet :: AttrLabelProxy "underlineSet"
cellRendererTextVariant :: AttrLabelProxy "variant"
cellRendererTextVariantSet :: AttrLabelProxy "variantSet"
cellRendererTextWeight :: AttrLabelProxy "weight"
cellRendererTextWeightSet :: AttrLabelProxy "weightSet"
cellRendererTextWidthChars :: AttrLabelProxy "widthChars"
cellRendererTextWrapMode :: AttrLabelProxy "wrapMode"
cellRendererTextWrapWidth :: AttrLabelProxy "wrapWidth"
cellRendererToggleActivatable :: AttrLabelProxy "activatable"
cellRendererToggleActive :: AttrLabelProxy "active"
cellRendererToggleInconsistent :: AttrLabelProxy "inconsistent"
cellRendererToggleIndicatorSize :: AttrLabelProxy "indicatorSize"
cellRendererToggleRadio :: AttrLabelProxy "radio"
cellViewBackground :: AttrLabelProxy "background"
cellViewBackgroundGdk :: AttrLabelProxy "backgroundGdk"
cellViewBackgroundRgba :: AttrLabelProxy "backgroundRgba"
cellViewBackgroundSet :: AttrLabelProxy "backgroundSet"
cellViewCellArea :: AttrLabelProxy "cellArea"
cellViewCellAreaContext :: AttrLabelProxy "cellAreaContext"
cellViewDrawSensitive :: AttrLabelProxy "drawSensitive"
cellViewFitModel :: AttrLabelProxy "fitModel"
cellViewModel :: AttrLabelProxy "model"
checkMenuItemActive :: AttrLabelProxy "active"
checkMenuItemDrawAsRadio :: AttrLabelProxy "drawAsRadio"
checkMenuItemInconsistent :: AttrLabelProxy "inconsistent"
colorButtonAlpha :: AttrLabelProxy "alpha"
colorButtonColor :: AttrLabelProxy "color"
colorButtonRgba :: AttrLabelProxy "rgba"
colorButtonShowEditor :: AttrLabelProxy "showEditor"
colorButtonTitle :: AttrLabelProxy "title"
colorButtonUseAlpha :: AttrLabelProxy "useAlpha"
colorChooserDialogShowEditor :: AttrLabelProxy "showEditor"
colorChooserWidgetShowEditor :: AttrLabelProxy "showEditor"
colorSelectionCurrentAlpha :: AttrLabelProxy "currentAlpha"
colorSelectionCurrentColor :: AttrLabelProxy "currentColor"
colorSelectionCurrentRgba :: AttrLabelProxy "currentRgba"
colorSelectionHasOpacityControl :: AttrLabelProxy "hasOpacityControl"
colorSelectionHasPalette :: AttrLabelProxy "hasPalette"
colorSelectionDialogCancelButton :: AttrLabelProxy "cancelButton"
colorSelectionDialogColorSelection :: AttrLabelProxy "colorSelection"
colorSelectionDialogHelpButton :: AttrLabelProxy "helpButton"
colorSelectionDialogOkButton :: AttrLabelProxy "okButton"
comboBoxActive :: AttrLabelProxy "active"
comboBoxActiveId :: AttrLabelProxy "activeId"
comboBoxAddTearoffs :: AttrLabelProxy "addTearoffs"
comboBoxButtonSensitivity :: AttrLabelProxy "buttonSensitivity"
comboBoxCellArea :: AttrLabelProxy "cellArea"
comboBoxColumnSpanColumn :: AttrLabelProxy "columnSpanColumn"
comboBoxEntryTextColumn :: AttrLabelProxy "entryTextColumn"
comboBoxHasEntry :: AttrLabelProxy "hasEntry"
comboBoxHasFrame :: AttrLabelProxy "hasFrame"
comboBoxIdColumn :: AttrLabelProxy "idColumn"
comboBoxModel :: AttrLabelProxy "model"
comboBoxPopupFixedWidth :: AttrLabelProxy "popupFixedWidth"
comboBoxPopupShown :: AttrLabelProxy "popupShown"
comboBoxRowSpanColumn :: AttrLabelProxy "rowSpanColumn"
comboBoxTearoffTitle :: AttrLabelProxy "tearoffTitle"
comboBoxWrapWidth :: AttrLabelProxy "wrapWidth"
containerBorderWidth :: AttrLabelProxy "borderWidth"
containerChild :: AttrLabelProxy "child"
containerResizeMode :: AttrLabelProxy "resizeMode"
dialogUseHeaderBar :: AttrLabelProxy "useHeaderBar"
entryActivatesDefault :: AttrLabelProxy "activatesDefault"
entryAttributes :: AttrLabelProxy "attributes"
entryBuffer :: AttrLabelProxy "buffer"
entryCapsLockWarning :: AttrLabelProxy "capsLockWarning"
entryCompletion :: AttrLabelProxy "completion"
entryCursorPosition :: AttrLabelProxy "cursorPosition"
entryEditable :: AttrLabelProxy "editable"
entryEnableEmojiCompletion :: AttrLabelProxy "enableEmojiCompletion"
entryHasFrame :: AttrLabelProxy "hasFrame"
entryImModule :: AttrLabelProxy "imModule"
entryInnerBorder :: AttrLabelProxy "innerBorder"
entryInputHints :: AttrLabelProxy "inputHints"
entryInputPurpose :: AttrLabelProxy "inputPurpose"
entryInvisibleChar :: AttrLabelProxy "invisibleChar"
entryInvisibleCharSet :: AttrLabelProxy "invisibleCharSet"
entryMaxLength :: AttrLabelProxy "maxLength"
entryMaxWidthChars :: AttrLabelProxy "maxWidthChars"
entryOverwriteMode :: AttrLabelProxy "overwriteMode"
entryPlaceholderText :: AttrLabelProxy "placeholderText"
entryPopulateAll :: AttrLabelProxy "populateAll"
entryPrimaryIconActivatable :: AttrLabelProxy "primaryIconActivatable"
entryPrimaryIconGicon :: AttrLabelProxy "primaryIconGicon"
entryPrimaryIconName :: AttrLabelProxy "primaryIconName"
entryPrimaryIconPixbuf :: AttrLabelProxy "primaryIconPixbuf"
entryPrimaryIconSensitive :: AttrLabelProxy "primaryIconSensitive"
entryPrimaryIconStock :: AttrLabelProxy "primaryIconStock"
entryPrimaryIconStorageType :: AttrLabelProxy "primaryIconStorageType"
entryPrimaryIconTooltipMarkup :: AttrLabelProxy "primaryIconTooltipMarkup"
entryPrimaryIconTooltipText :: AttrLabelProxy "primaryIconTooltipText"
entryProgressFraction :: AttrLabelProxy "progressFraction"
entryProgressPulseStep :: AttrLabelProxy "progressPulseStep"
entryScrollOffset :: AttrLabelProxy "scrollOffset"
entrySecondaryIconActivatable :: AttrLabelProxy "secondaryIconActivatable"
entrySecondaryIconGicon :: AttrLabelProxy "secondaryIconGicon"
entrySecondaryIconName :: AttrLabelProxy "secondaryIconName"
entrySecondaryIconPixbuf :: AttrLabelProxy "secondaryIconPixbuf"
entrySecondaryIconSensitive :: AttrLabelProxy "secondaryIconSensitive"
entrySecondaryIconStock :: AttrLabelProxy "secondaryIconStock"
entrySecondaryIconStorageType :: AttrLabelProxy "secondaryIconStorageType"
entrySecondaryIconTooltipMarkup :: AttrLabelProxy "secondaryIconTooltipMarkup"
entrySecondaryIconTooltipText :: AttrLabelProxy "secondaryIconTooltipText"
entrySelectionBound :: AttrLabelProxy "selectionBound"
entryShadowType :: AttrLabelProxy "shadowType"
entryShowEmojiIcon :: AttrLabelProxy "showEmojiIcon"
entryTabs :: AttrLabelProxy "tabs"
entryText :: AttrLabelProxy "text"
entryTextLength :: AttrLabelProxy "textLength"
entryTruncateMultiline :: AttrLabelProxy "truncateMultiline"
entryVisibility :: AttrLabelProxy "visibility"
entryWidthChars :: AttrLabelProxy "widthChars"
entryXalign :: AttrLabelProxy "xalign"
entryBufferLength :: AttrLabelProxy "length"
entryBufferMaxLength :: AttrLabelProxy "maxLength"
entryBufferText :: AttrLabelProxy "text"
entryCompletionCellArea :: AttrLabelProxy "cellArea"
entryCompletionInlineCompletion :: AttrLabelProxy "inlineCompletion"
entryCompletionInlineSelection :: AttrLabelProxy "inlineSelection"
entryCompletionMinimumKeyLength :: AttrLabelProxy "minimumKeyLength"
entryCompletionModel :: AttrLabelProxy "model"
entryCompletionPopupCompletion :: AttrLabelProxy "popupCompletion"
entryCompletionPopupSetWidth :: AttrLabelProxy "popupSetWidth"
entryCompletionPopupSingleMatch :: AttrLabelProxy "popupSingleMatch"
entryCompletionTextColumn :: AttrLabelProxy "textColumn"
eventBoxAboveChild :: AttrLabelProxy "aboveChild"
eventBoxVisibleWindow :: AttrLabelProxy "visibleWindow"
eventControllerPropagationPhase :: AttrLabelProxy "propagationPhase"
eventControllerWidget :: AttrLabelProxy "widget"
eventControllerScrollFlags :: AttrLabelProxy "flags"
expanderExpanded :: AttrLabelProxy "expanded"
expanderLabel :: AttrLabelProxy "label"
expanderLabelFill :: AttrLabelProxy "labelFill"
expanderLabelWidget :: AttrLabelProxy "labelWidget"
expanderResizeToplevel :: AttrLabelProxy "resizeToplevel"
expanderSpacing :: AttrLabelProxy "spacing"
expanderUseMarkup :: AttrLabelProxy "useMarkup"
expanderUseUnderline :: AttrLabelProxy "useUnderline"
fileChooserButtonDialog :: AttrLabelProxy "dialog"
fileChooserButtonTitle :: AttrLabelProxy "title"
fileChooserButtonWidthChars :: AttrLabelProxy "widthChars"
fileChooserNativeAcceptLabel :: AttrLabelProxy "acceptLabel"
fileChooserNativeCancelLabel :: AttrLabelProxy "cancelLabel"
fileChooserWidgetSearchMode :: AttrLabelProxy "searchMode"
fileChooserWidgetSubtitle :: AttrLabelProxy "subtitle"
flowBoxActivateOnSingleClick :: AttrLabelProxy "activateOnSingleClick"
flowBoxColumnSpacing :: AttrLabelProxy "columnSpacing"
flowBoxHomogeneous :: AttrLabelProxy "homogeneous"
flowBoxMaxChildrenPerLine :: AttrLabelProxy "maxChildrenPerLine"
flowBoxMinChildrenPerLine :: AttrLabelProxy "minChildrenPerLine"
flowBoxRowSpacing :: AttrLabelProxy "rowSpacing"
flowBoxSelectionMode :: AttrLabelProxy "selectionMode"
fontButtonFontName :: AttrLabelProxy "fontName"
fontButtonShowSize :: AttrLabelProxy "showSize"
fontButtonShowStyle :: AttrLabelProxy "showStyle"
fontButtonTitle :: AttrLabelProxy "title"
fontButtonUseFont :: AttrLabelProxy "useFont"
fontButtonUseSize :: AttrLabelProxy "useSize"
fontChooserWidgetTweakAction :: AttrLabelProxy "tweakAction"
fontSelectionFontName :: AttrLabelProxy "fontName"
fontSelectionPreviewText :: AttrLabelProxy "previewText"
frameLabel :: AttrLabelProxy "label"
frameLabelWidget :: AttrLabelProxy "labelWidget"
frameLabelXalign :: AttrLabelProxy "labelXalign"
frameLabelYalign :: AttrLabelProxy "labelYalign"
frameShadowType :: AttrLabelProxy "shadowType"
gLAreaAutoRender :: AttrLabelProxy "autoRender"
gLAreaContext :: AttrLabelProxy "context"
gLAreaHasAlpha :: AttrLabelProxy "hasAlpha"
gLAreaHasDepthBuffer :: AttrLabelProxy "hasDepthBuffer"
gLAreaHasStencilBuffer :: AttrLabelProxy "hasStencilBuffer"
gLAreaUseEs :: AttrLabelProxy "useEs"
gestureNPoints :: AttrLabelProxy "nPoints"
gestureWindow :: AttrLabelProxy "window"
gestureLongPressDelayFactor :: AttrLabelProxy "delayFactor"
gesturePanOrientation :: AttrLabelProxy "orientation"
gestureSingleButton :: AttrLabelProxy "button"
gestureSingleExclusive :: AttrLabelProxy "exclusive"
gestureSingleTouchOnly :: AttrLabelProxy "touchOnly"
gridBaselineRow :: AttrLabelProxy "baselineRow"
gridColumnHomogeneous :: AttrLabelProxy "columnHomogeneous"
gridColumnSpacing :: AttrLabelProxy "columnSpacing"
gridRowHomogeneous :: AttrLabelProxy "rowHomogeneous"
gridRowSpacing :: AttrLabelProxy "rowSpacing"
handleBoxChildDetached :: AttrLabelProxy "childDetached"
handleBoxHandlePosition :: AttrLabelProxy "handlePosition"
handleBoxShadowType :: AttrLabelProxy "shadowType"
handleBoxSnapEdge :: AttrLabelProxy "snapEdge"
handleBoxSnapEdgeSet :: AttrLabelProxy "snapEdgeSet"
headerBarCustomTitle :: AttrLabelProxy "customTitle"
headerBarDecorationLayout :: AttrLabelProxy "decorationLayout"
headerBarDecorationLayoutSet :: AttrLabelProxy "decorationLayoutSet"
headerBarHasSubtitle :: AttrLabelProxy "hasSubtitle"
headerBarShowCloseButton :: AttrLabelProxy "showCloseButton"
headerBarSpacing :: AttrLabelProxy "spacing"
headerBarSubtitle :: AttrLabelProxy "subtitle"
headerBarTitle :: AttrLabelProxy "title"
iMContextInputHints :: AttrLabelProxy "inputHints"
iMContextInputPurpose :: AttrLabelProxy "inputPurpose"
iconViewActivateOnSingleClick :: AttrLabelProxy "activateOnSingleClick"
iconViewCellArea :: AttrLabelProxy "cellArea"
iconViewColumnSpacing :: AttrLabelProxy "columnSpacing"
iconViewColumns :: AttrLabelProxy "columns"
iconViewItemOrientation :: AttrLabelProxy "itemOrientation"
iconViewItemPadding :: AttrLabelProxy "itemPadding"
iconViewItemWidth :: AttrLabelProxy "itemWidth"
iconViewMargin :: AttrLabelProxy "margin"
iconViewMarkupColumn :: AttrLabelProxy "markupColumn"
iconViewModel :: AttrLabelProxy "model"
iconViewPixbufColumn :: AttrLabelProxy "pixbufColumn"
iconViewReorderable :: AttrLabelProxy "reorderable"
iconViewRowSpacing :: AttrLabelProxy "rowSpacing"
iconViewSelectionMode :: AttrLabelProxy "selectionMode"
iconViewSpacing :: AttrLabelProxy "spacing"
iconViewTextColumn :: AttrLabelProxy "textColumn"
iconViewTooltipColumn :: AttrLabelProxy "tooltipColumn"
imageFile :: AttrLabelProxy "file"
imageGicon :: AttrLabelProxy "gicon"
imageIconName :: AttrLabelProxy "iconName"
imageIconSet :: AttrLabelProxy "iconSet"
imageIconSize :: AttrLabelProxy "iconSize"
imagePixbuf :: AttrLabelProxy "pixbuf"
imagePixbufAnimation :: AttrLabelProxy "pixbufAnimation"
imagePixelSize :: AttrLabelProxy "pixelSize"
imageResource :: AttrLabelProxy "resource"
imageStock :: AttrLabelProxy "stock"
imageStorageType :: AttrLabelProxy "storageType"
imageSurface :: AttrLabelProxy "surface"
imageUseFallback :: AttrLabelProxy "useFallback"
imageMenuItemAccelGroup :: AttrLabelProxy "accelGroup"
imageMenuItemAlwaysShowImage :: AttrLabelProxy "alwaysShowImage"
imageMenuItemImage :: AttrLabelProxy "image"
imageMenuItemUseStock :: AttrLabelProxy "useStock"
infoBarMessageType :: AttrLabelProxy "messageType"
infoBarRevealed :: AttrLabelProxy "revealed"
infoBarShowCloseButton :: AttrLabelProxy "showCloseButton"
invisibleScreen :: AttrLabelProxy "screen"
labelAngle :: AttrLabelProxy "angle"
labelAttributes :: AttrLabelProxy "attributes"
labelCursorPosition :: AttrLabelProxy "cursorPosition"
labelEllipsize :: AttrLabelProxy "ellipsize"
labelJustify :: AttrLabelProxy "justify"
labelLabel :: AttrLabelProxy "label"
labelLines :: AttrLabelProxy "lines"
labelMaxWidthChars :: AttrLabelProxy "maxWidthChars"
labelMnemonicKeyval :: AttrLabelProxy "mnemonicKeyval"
labelMnemonicWidget :: AttrLabelProxy "mnemonicWidget"
labelPattern :: AttrLabelProxy "pattern"
labelSelectable :: AttrLabelProxy "selectable"
labelSelectionBound :: AttrLabelProxy "selectionBound"
labelSingleLineMode :: AttrLabelProxy "singleLineMode"
labelTrackVisitedLinks :: AttrLabelProxy "trackVisitedLinks"
labelUseMarkup :: AttrLabelProxy "useMarkup"
labelUseUnderline :: AttrLabelProxy "useUnderline"
labelWidthChars :: AttrLabelProxy "widthChars"
labelWrap :: AttrLabelProxy "wrap"
labelWrapMode :: AttrLabelProxy "wrapMode"
labelXalign :: AttrLabelProxy "xalign"
labelYalign :: AttrLabelProxy "yalign"
layoutHeight :: AttrLabelProxy "height"
layoutWidth :: AttrLabelProxy "width"
levelBarInverted :: AttrLabelProxy "inverted"
levelBarMaxValue :: AttrLabelProxy "maxValue"
levelBarMinValue :: AttrLabelProxy "minValue"
levelBarMode :: AttrLabelProxy "mode"
levelBarValue :: AttrLabelProxy "value"
linkButtonUri :: AttrLabelProxy "uri"
linkButtonVisited :: AttrLabelProxy "visited"
listBoxActivateOnSingleClick :: AttrLabelProxy "activateOnSingleClick"
listBoxSelectionMode :: AttrLabelProxy "selectionMode"
listBoxRowActivatable :: AttrLabelProxy "activatable"
listBoxRowSelectable :: AttrLabelProxy "selectable"
lockButtonPermission :: AttrLabelProxy "permission"
lockButtonTextLock :: AttrLabelProxy "textLock"
lockButtonTextUnlock :: AttrLabelProxy "textUnlock"
lockButtonTooltipLock :: AttrLabelProxy "tooltipLock"
lockButtonTooltipNotAuthorized :: AttrLabelProxy "tooltipNotAuthorized"
lockButtonTooltipUnlock :: AttrLabelProxy "tooltipUnlock"
menuAccelGroup :: AttrLabelProxy "accelGroup"
menuAccelPath :: AttrLabelProxy "accelPath"
menuActive :: AttrLabelProxy "active"
menuAnchorHints :: AttrLabelProxy "anchorHints"
menuAttachWidget :: AttrLabelProxy "attachWidget"
menuMenuTypeHint :: AttrLabelProxy "menuTypeHint"
menuMonitor :: AttrLabelProxy "monitor"
menuRectAnchorDx :: AttrLabelProxy "rectAnchorDx"
menuRectAnchorDy :: AttrLabelProxy "rectAnchorDy"
menuReserveToggleSize :: AttrLabelProxy "reserveToggleSize"
menuTearoffState :: AttrLabelProxy "tearoffState"
menuTearoffTitle :: AttrLabelProxy "tearoffTitle"
menuBarChildPackDirection :: AttrLabelProxy "childPackDirection"
menuBarPackDirection :: AttrLabelProxy "packDirection"
menuButtonAlignWidget :: AttrLabelProxy "alignWidget"
menuButtonDirection :: AttrLabelProxy "direction"
menuButtonMenuModel :: AttrLabelProxy "menuModel"
menuButtonPopover :: AttrLabelProxy "popover"
menuButtonPopup :: AttrLabelProxy "popup"
menuButtonUsePopover :: AttrLabelProxy "usePopover"
menuItemAccelPath :: AttrLabelProxy "accelPath"
menuItemLabel :: AttrLabelProxy "label"
menuItemRightJustified :: AttrLabelProxy "rightJustified"
menuItemSubmenu :: AttrLabelProxy "submenu"
menuItemUseUnderline :: AttrLabelProxy "useUnderline"
menuShellTakeFocus :: AttrLabelProxy "takeFocus"
menuToolButtonMenu :: AttrLabelProxy "menu"
messageDialogButtons :: AttrLabelProxy "buttons"
messageDialogImage :: AttrLabelProxy "image"
messageDialogMessageArea :: AttrLabelProxy "messageArea"
messageDialogMessageType :: AttrLabelProxy "messageType"
messageDialogSecondaryText :: AttrLabelProxy "secondaryText"
messageDialogSecondaryUseMarkup :: AttrLabelProxy "secondaryUseMarkup"
messageDialogText :: AttrLabelProxy "text"
messageDialogUseMarkup :: AttrLabelProxy "useMarkup"
miscXalign :: AttrLabelProxy "xalign"
miscXpad :: AttrLabelProxy "xpad"
miscYalign :: AttrLabelProxy "yalign"
miscYpad :: AttrLabelProxy "ypad"
modelButtonActive :: AttrLabelProxy "active"
modelButtonCentered :: AttrLabelProxy "centered"
modelButtonIcon :: AttrLabelProxy "icon"
modelButtonIconic :: AttrLabelProxy "iconic"
modelButtonInverted :: AttrLabelProxy "inverted"
modelButtonMenuName :: AttrLabelProxy "menuName"
modelButtonRole :: AttrLabelProxy "role"
modelButtonText :: AttrLabelProxy "text"
modelButtonUseMarkup :: AttrLabelProxy "useMarkup"
mountOperationParent :: AttrLabelProxy "parent"
mountOperationScreen :: AttrLabelProxy "screen"
nativeDialogModal :: AttrLabelProxy "modal"
nativeDialogTitle :: AttrLabelProxy "title"
nativeDialogTransientFor :: AttrLabelProxy "transientFor"
nativeDialogVisible :: AttrLabelProxy "visible"
notebookEnablePopup :: AttrLabelProxy "enablePopup"
notebookGroupName :: AttrLabelProxy "groupName"
notebookPage :: AttrLabelProxy "page"
notebookScrollable :: AttrLabelProxy "scrollable"
notebookShowBorder :: AttrLabelProxy "showBorder"
notebookShowTabs :: AttrLabelProxy "showTabs"
notebookTabPos :: AttrLabelProxy "tabPos"
numerableIconBackgroundIcon :: AttrLabelProxy "backgroundIcon"
numerableIconBackgroundIconName :: AttrLabelProxy "backgroundIconName"
numerableIconCount :: AttrLabelProxy "count"
numerableIconLabel :: AttrLabelProxy "label"
numerableIconStyleContext :: AttrLabelProxy "styleContext"
padControllerActionGroup :: AttrLabelProxy "actionGroup"
padControllerPad :: AttrLabelProxy "pad"
panedMaxPosition :: AttrLabelProxy "maxPosition"
panedMinPosition :: AttrLabelProxy "minPosition"
panedPosition :: AttrLabelProxy "position"
panedPositionSet :: AttrLabelProxy "positionSet"
panedWideHandle :: AttrLabelProxy "wideHandle"
placesSidebarLocalOnly :: AttrLabelProxy "localOnly"
placesSidebarLocation :: AttrLabelProxy "location"
placesSidebarOpenFlags :: AttrLabelProxy "openFlags"
placesSidebarPopulateAll :: AttrLabelProxy "populateAll"
placesSidebarShowConnectToServer :: AttrLabelProxy "showConnectToServer"
placesSidebarShowDesktop :: AttrLabelProxy "showDesktop"
placesSidebarShowEnterLocation :: AttrLabelProxy "showEnterLocation"
placesSidebarShowOtherLocations :: AttrLabelProxy "showOtherLocations"
placesSidebarShowRecent :: AttrLabelProxy "showRecent"
placesSidebarShowStarredLocation :: AttrLabelProxy "showStarredLocation"
placesSidebarShowTrash :: AttrLabelProxy "showTrash"
plugEmbedded :: AttrLabelProxy "embedded"
plugSocketWindow :: AttrLabelProxy "socketWindow"
popoverConstrainTo :: AttrLabelProxy "constrainTo"
popoverModal :: AttrLabelProxy "modal"
popoverPointingTo :: AttrLabelProxy "pointingTo"
popoverPosition :: AttrLabelProxy "position"
popoverRelativeTo :: AttrLabelProxy "relativeTo"
popoverTransitionsEnabled :: AttrLabelProxy "transitionsEnabled"
popoverMenuVisibleSubmenu :: AttrLabelProxy "visibleSubmenu"
printOperationAllowAsync :: AttrLabelProxy "allowAsync"
printOperationCurrentPage :: AttrLabelProxy "currentPage"
printOperationCustomTabLabel :: AttrLabelProxy "customTabLabel"
printOperationDefaultPageSetup :: AttrLabelProxy "defaultPageSetup"
printOperationEmbedPageSetup :: AttrLabelProxy "embedPageSetup"
printOperationExportFilename :: AttrLabelProxy "exportFilename"
printOperationHasSelection :: AttrLabelProxy "hasSelection"
printOperationJobName :: AttrLabelProxy "jobName"
printOperationNPages :: AttrLabelProxy "nPages"
printOperationNPagesToPrint :: AttrLabelProxy "nPagesToPrint"
printOperationPrintSettings :: AttrLabelProxy "printSettings"
printOperationShowProgress :: AttrLabelProxy "showProgress"
printOperationStatus :: AttrLabelProxy "status"
printOperationStatusString :: AttrLabelProxy "statusString"
printOperationSupportSelection :: AttrLabelProxy "supportSelection"
printOperationTrackPrintStatus :: AttrLabelProxy "trackPrintStatus"
printOperationUnit :: AttrLabelProxy "unit"
printOperationUseFullPage :: AttrLabelProxy "useFullPage"
progressBarEllipsize :: AttrLabelProxy "ellipsize"
progressBarFraction :: AttrLabelProxy "fraction"
progressBarInverted :: AttrLabelProxy "inverted"
progressBarPulseStep :: AttrLabelProxy "pulseStep"
progressBarShowText :: AttrLabelProxy "showText"
progressBarText :: AttrLabelProxy "text"
radioActionCurrentValue :: AttrLabelProxy "currentValue"
radioActionGroup :: AttrLabelProxy "group"
radioActionValue :: AttrLabelProxy "value"
radioButtonGroup :: AttrLabelProxy "group"
radioMenuItemGroup :: AttrLabelProxy "group"
radioToolButtonGroup :: AttrLabelProxy "group"
rangeAdjustment :: AttrLabelProxy "adjustment"
rangeFillLevel :: AttrLabelProxy "fillLevel"
rangeInverted :: AttrLabelProxy "inverted"
rangeLowerStepperSensitivity :: AttrLabelProxy "lowerStepperSensitivity"
rangeRestrictToFillLevel :: AttrLabelProxy "restrictToFillLevel"
rangeRoundDigits :: AttrLabelProxy "roundDigits"
rangeShowFillLevel :: AttrLabelProxy "showFillLevel"
rangeUpperStepperSensitivity :: AttrLabelProxy "upperStepperSensitivity"
recentActionShowNumbers :: AttrLabelProxy "showNumbers"
recentChooserMenuShowNumbers :: AttrLabelProxy "showNumbers"
recentManagerFilename :: AttrLabelProxy "filename"
recentManagerSize :: AttrLabelProxy "size"
rendererCellAccessibleRenderer :: AttrLabelProxy "renderer"
revealerChildRevealed :: AttrLabelProxy "childRevealed"
revealerRevealChild :: AttrLabelProxy "revealChild"
revealerTransitionDuration :: AttrLabelProxy "transitionDuration"
revealerTransitionType :: AttrLabelProxy "transitionType"
scaleDigits :: AttrLabelProxy "digits"
scaleDrawValue :: AttrLabelProxy "drawValue"
scaleHasOrigin :: AttrLabelProxy "hasOrigin"
scaleValuePos :: AttrLabelProxy "valuePos"
scaleButtonAdjustment :: AttrLabelProxy "adjustment"
scaleButtonIcons :: AttrLabelProxy "icons"
scaleButtonSize :: AttrLabelProxy "size"
scaleButtonValue :: AttrLabelProxy "value"
scrolledWindowHadjustment :: AttrLabelProxy "hadjustment"
scrolledWindowHscrollbarPolicy :: AttrLabelProxy "hscrollbarPolicy"
scrolledWindowKineticScrolling :: AttrLabelProxy "kineticScrolling"
scrolledWindowMaxContentHeight :: AttrLabelProxy "maxContentHeight"
scrolledWindowMaxContentWidth :: AttrLabelProxy "maxContentWidth"
scrolledWindowMinContentHeight :: AttrLabelProxy "minContentHeight"
scrolledWindowMinContentWidth :: AttrLabelProxy "minContentWidth"
scrolledWindowOverlayScrolling :: AttrLabelProxy "overlayScrolling"
scrolledWindowPropagateNaturalHeight :: AttrLabelProxy "propagateNaturalHeight"
scrolledWindowPropagateNaturalWidth :: AttrLabelProxy "propagateNaturalWidth"
scrolledWindowShadowType :: AttrLabelProxy "shadowType"
scrolledWindowVadjustment :: AttrLabelProxy "vadjustment"
scrolledWindowVscrollbarPolicy :: AttrLabelProxy "vscrollbarPolicy"
scrolledWindowWindowPlacement :: AttrLabelProxy "windowPlacement"
scrolledWindowWindowPlacementSet :: AttrLabelProxy "windowPlacementSet"
searchBarSearchModeEnabled :: AttrLabelProxy "searchModeEnabled"
searchBarShowCloseButton :: AttrLabelProxy "showCloseButton"
separatorToolItemDraw :: AttrLabelProxy "draw"
settingsColorHash :: AttrLabelProxy "colorHash"
settingsGtkAlternativeButtonOrder :: AttrLabelProxy "gtkAlternativeButtonOrder"
settingsGtkAlternativeSortArrows :: AttrLabelProxy "gtkAlternativeSortArrows"
settingsGtkApplicationPreferDarkTheme :: AttrLabelProxy "gtkApplicationPreferDarkTheme"
settingsGtkAutoMnemonics :: AttrLabelProxy "gtkAutoMnemonics"
settingsGtkButtonImages :: AttrLabelProxy "gtkButtonImages"
settingsGtkCanChangeAccels :: AttrLabelProxy "gtkCanChangeAccels"
settingsGtkColorPalette :: AttrLabelProxy "gtkColorPalette"
settingsGtkColorScheme :: AttrLabelProxy "gtkColorScheme"
settingsGtkCursorAspectRatio :: AttrLabelProxy "gtkCursorAspectRatio"
settingsGtkCursorBlink :: AttrLabelProxy "gtkCursorBlink"
settingsGtkCursorBlinkTime :: AttrLabelProxy "gtkCursorBlinkTime"
settingsGtkCursorBlinkTimeout :: AttrLabelProxy "gtkCursorBlinkTimeout"
settingsGtkCursorThemeName :: AttrLabelProxy "gtkCursorThemeName"
settingsGtkCursorThemeSize :: AttrLabelProxy "gtkCursorThemeSize"
settingsGtkDecorationLayout :: AttrLabelProxy "gtkDecorationLayout"
settingsGtkDialogsUseHeader :: AttrLabelProxy "gtkDialogsUseHeader"
settingsGtkDndDragThreshold :: AttrLabelProxy "gtkDndDragThreshold"
settingsGtkDoubleClickDistance :: AttrLabelProxy "gtkDoubleClickDistance"
settingsGtkDoubleClickTime :: AttrLabelProxy "gtkDoubleClickTime"
settingsGtkEnableAccels :: AttrLabelProxy "gtkEnableAccels"
settingsGtkEnableAnimations :: AttrLabelProxy "gtkEnableAnimations"
settingsGtkEnableEventSounds :: AttrLabelProxy "gtkEnableEventSounds"
settingsGtkEnableInputFeedbackSounds :: AttrLabelProxy "gtkEnableInputFeedbackSounds"
settingsGtkEnableMnemonics :: AttrLabelProxy "gtkEnableMnemonics"
settingsGtkEnablePrimaryPaste :: AttrLabelProxy "gtkEnablePrimaryPaste"
settingsGtkEnableTooltips :: AttrLabelProxy "gtkEnableTooltips"
settingsGtkEntryPasswordHintTimeout :: AttrLabelProxy "gtkEntryPasswordHintTimeout"
settingsGtkEntrySelectOnFocus :: AttrLabelProxy "gtkEntrySelectOnFocus"
settingsGtkErrorBell :: AttrLabelProxy "gtkErrorBell"
settingsGtkFallbackIconTheme :: AttrLabelProxy "gtkFallbackIconTheme"
settingsGtkFileChooserBackend :: AttrLabelProxy "gtkFileChooserBackend"
settingsGtkFontName :: AttrLabelProxy "gtkFontName"
settingsGtkFontconfigTimestamp :: AttrLabelProxy "gtkFontconfigTimestamp"
settingsGtkIconSizes :: AttrLabelProxy "gtkIconSizes"
settingsGtkIconThemeName :: AttrLabelProxy "gtkIconThemeName"
settingsGtkImModule :: AttrLabelProxy "gtkImModule"
settingsGtkImPreeditStyle :: AttrLabelProxy "gtkImPreeditStyle"
settingsGtkImStatusStyle :: AttrLabelProxy "gtkImStatusStyle"
settingsGtkKeyThemeName :: AttrLabelProxy "gtkKeyThemeName"
settingsGtkKeynavCursorOnly :: AttrLabelProxy "gtkKeynavCursorOnly"
settingsGtkKeynavUseCaret :: AttrLabelProxy "gtkKeynavUseCaret"
settingsGtkKeynavWrapAround :: AttrLabelProxy "gtkKeynavWrapAround"
settingsGtkLabelSelectOnFocus :: AttrLabelProxy "gtkLabelSelectOnFocus"
settingsGtkLongPressTime :: AttrLabelProxy "gtkLongPressTime"
settingsGtkMenuBarAccel :: AttrLabelProxy "gtkMenuBarAccel"
settingsGtkMenuBarPopupDelay :: AttrLabelProxy "gtkMenuBarPopupDelay"
settingsGtkMenuImages :: AttrLabelProxy "gtkMenuImages"
settingsGtkMenuPopdownDelay :: AttrLabelProxy "gtkMenuPopdownDelay"
settingsGtkMenuPopupDelay :: AttrLabelProxy "gtkMenuPopupDelay"
settingsGtkModules :: AttrLabelProxy "gtkModules"
settingsGtkOverlayScrolling :: AttrLabelProxy "gtkOverlayScrolling"
settingsGtkPrimaryButtonWarpsSlider :: AttrLabelProxy "gtkPrimaryButtonWarpsSlider"
settingsGtkPrintBackends :: AttrLabelProxy "gtkPrintBackends"
settingsGtkPrintPreviewCommand :: AttrLabelProxy "gtkPrintPreviewCommand"
settingsGtkRecentFilesEnabled :: AttrLabelProxy "gtkRecentFilesEnabled"
settingsGtkRecentFilesLimit :: AttrLabelProxy "gtkRecentFilesLimit"
settingsGtkRecentFilesMaxAge :: AttrLabelProxy "gtkRecentFilesMaxAge"
settingsGtkScrolledWindowPlacement :: AttrLabelProxy "gtkScrolledWindowPlacement"
settingsGtkShellShowsAppMenu :: AttrLabelProxy "gtkShellShowsAppMenu"
settingsGtkShellShowsDesktop :: AttrLabelProxy "gtkShellShowsDesktop"
settingsGtkShellShowsMenubar :: AttrLabelProxy "gtkShellShowsMenubar"
settingsGtkShowInputMethodMenu :: AttrLabelProxy "gtkShowInputMethodMenu"
settingsGtkShowUnicodeMenu :: AttrLabelProxy "gtkShowUnicodeMenu"
settingsGtkSoundThemeName :: AttrLabelProxy "gtkSoundThemeName"
settingsGtkSplitCursor :: AttrLabelProxy "gtkSplitCursor"
settingsGtkThemeName :: AttrLabelProxy "gtkThemeName"
settingsGtkTimeoutExpand :: AttrLabelProxy "gtkTimeoutExpand"
settingsGtkTimeoutInitial :: AttrLabelProxy "gtkTimeoutInitial"
settingsGtkTimeoutRepeat :: AttrLabelProxy "gtkTimeoutRepeat"
settingsGtkTitlebarDoubleClick :: AttrLabelProxy "gtkTitlebarDoubleClick"
settingsGtkTitlebarMiddleClick :: AttrLabelProxy "gtkTitlebarMiddleClick"
settingsGtkTitlebarRightClick :: AttrLabelProxy "gtkTitlebarRightClick"
settingsGtkToolbarIconSize :: AttrLabelProxy "gtkToolbarIconSize"
settingsGtkToolbarStyle :: AttrLabelProxy "gtkToolbarStyle"
settingsGtkTooltipBrowseModeTimeout :: AttrLabelProxy "gtkTooltipBrowseModeTimeout"
settingsGtkTooltipBrowseTimeout :: AttrLabelProxy "gtkTooltipBrowseTimeout"
settingsGtkTooltipTimeout :: AttrLabelProxy "gtkTooltipTimeout"
settingsGtkTouchscreenMode :: AttrLabelProxy "gtkTouchscreenMode"
settingsGtkVisibleFocus :: AttrLabelProxy "gtkVisibleFocus"
settingsGtkXftAntialias :: AttrLabelProxy "gtkXftAntialias"
settingsGtkXftDpi :: AttrLabelProxy "gtkXftDpi"
settingsGtkXftHinting :: AttrLabelProxy "gtkXftHinting"
settingsGtkXftHintstyle :: AttrLabelProxy "gtkXftHintstyle"
settingsGtkXftRgba :: AttrLabelProxy "gtkXftRgba"
shortcutLabelAccelerator :: AttrLabelProxy "accelerator"
shortcutLabelDisabledText :: AttrLabelProxy "disabledText"
shortcutsGroupAccelSizeGroup :: AttrLabelProxy "accelSizeGroup"
shortcutsGroupHeight :: AttrLabelProxy "height"
shortcutsGroupTitle :: AttrLabelProxy "title"
shortcutsGroupTitleSizeGroup :: AttrLabelProxy "titleSizeGroup"
shortcutsGroupView :: AttrLabelProxy "view"
shortcutsSectionMaxHeight :: AttrLabelProxy "maxHeight"
shortcutsSectionSectionName :: AttrLabelProxy "sectionName"
shortcutsSectionTitle :: AttrLabelProxy "title"
shortcutsSectionViewName :: AttrLabelProxy "viewName"
shortcutsShortcutAccelSizeGroup :: AttrLabelProxy "accelSizeGroup"
shortcutsShortcutAccelerator :: AttrLabelProxy "accelerator"
shortcutsShortcutActionName :: AttrLabelProxy "actionName"
shortcutsShortcutDirection :: AttrLabelProxy "direction"
shortcutsShortcutIcon :: AttrLabelProxy "icon"
shortcutsShortcutIconSet :: AttrLabelProxy "iconSet"
shortcutsShortcutShortcutType :: AttrLabelProxy "shortcutType"
shortcutsShortcutSubtitle :: AttrLabelProxy "subtitle"
shortcutsShortcutSubtitleSet :: AttrLabelProxy "subtitleSet"
shortcutsShortcutTitle :: AttrLabelProxy "title"
shortcutsShortcutTitleSizeGroup :: AttrLabelProxy "titleSizeGroup"
shortcutsWindowSectionName :: AttrLabelProxy "sectionName"
shortcutsWindowViewName :: AttrLabelProxy "viewName"
sizeGroupIgnoreHidden :: AttrLabelProxy "ignoreHidden"
sizeGroupMode :: AttrLabelProxy "mode"
spinButtonAdjustment :: AttrLabelProxy "adjustment"
spinButtonClimbRate :: AttrLabelProxy "climbRate"
spinButtonDigits :: AttrLabelProxy "digits"
spinButtonNumeric :: AttrLabelProxy "numeric"
spinButtonSnapToTicks :: AttrLabelProxy "snapToTicks"
spinButtonUpdatePolicy :: AttrLabelProxy "updatePolicy"
spinButtonValue :: AttrLabelProxy "value"
spinButtonWrap :: AttrLabelProxy "wrap"
spinnerActive :: AttrLabelProxy "active"
stackHhomogeneous :: AttrLabelProxy "hhomogeneous"
stackHomogeneous :: AttrLabelProxy "homogeneous"
stackInterpolateSize :: AttrLabelProxy "interpolateSize"
stackTransitionDuration :: AttrLabelProxy "transitionDuration"
stackTransitionRunning :: AttrLabelProxy "transitionRunning"
stackTransitionType :: AttrLabelProxy "transitionType"
stackVhomogeneous :: AttrLabelProxy "vhomogeneous"
stackVisibleChild :: AttrLabelProxy "visibleChild"
stackVisibleChildName :: AttrLabelProxy "visibleChildName"
stackSidebarStack :: AttrLabelProxy "stack"
stackSwitcherIconSize :: AttrLabelProxy "iconSize"
stackSwitcherStack :: AttrLabelProxy "stack"
statusIconEmbedded :: AttrLabelProxy "embedded"
statusIconFile :: AttrLabelProxy "file"
statusIconGicon :: AttrLabelProxy "gicon"
statusIconHasTooltip :: AttrLabelProxy "hasTooltip"
statusIconIconName :: AttrLabelProxy "iconName"
statusIconOrientation :: AttrLabelProxy "orientation"
statusIconPixbuf :: AttrLabelProxy "pixbuf"
statusIconScreen :: AttrLabelProxy "screen"
statusIconSize :: AttrLabelProxy "size"
statusIconStock :: AttrLabelProxy "stock"
statusIconStorageType :: AttrLabelProxy "storageType"
statusIconTitle :: AttrLabelProxy "title"
statusIconTooltipMarkup :: AttrLabelProxy "tooltipMarkup"
statusIconTooltipText :: AttrLabelProxy "tooltipText"
statusIconVisible :: AttrLabelProxy "visible"
styleContext :: AttrLabelProxy "context"
styleContextDirection :: AttrLabelProxy "direction"
styleContextPaintClock :: AttrLabelProxy "paintClock"
styleContextParent :: AttrLabelProxy "parent"
styleContextScreen :: AttrLabelProxy "screen"
switchActive :: AttrLabelProxy "active"
switchState :: AttrLabelProxy "state"
tableColumnSpacing :: AttrLabelProxy "columnSpacing"
tableHomogeneous :: AttrLabelProxy "homogeneous"
tableNColumns :: AttrLabelProxy "nColumns"
tableNRows :: AttrLabelProxy "nRows"
tableRowSpacing :: AttrLabelProxy "rowSpacing"
textBufferCopyTargetList :: AttrLabelProxy "copyTargetList"
textBufferCursorPosition :: AttrLabelProxy "cursorPosition"
textBufferHasSelection :: AttrLabelProxy "hasSelection"
textBufferPasteTargetList :: AttrLabelProxy "pasteTargetList"
textBufferTagTable :: AttrLabelProxy "tagTable"
textBufferText :: AttrLabelProxy "text"
textMarkLeftGravity :: AttrLabelProxy "leftGravity"
textMarkName :: AttrLabelProxy "name"
textTagAccumulativeMargin :: AttrLabelProxy "accumulativeMargin"
textTagBackground :: AttrLabelProxy "background"
textTagBackgroundFullHeight :: AttrLabelProxy "backgroundFullHeight"
textTagBackgroundFullHeightSet :: AttrLabelProxy "backgroundFullHeightSet"
textTagBackgroundGdk :: AttrLabelProxy "backgroundGdk"
textTagBackgroundRgba :: AttrLabelProxy "backgroundRgba"
textTagBackgroundSet :: AttrLabelProxy "backgroundSet"
textTagDirection :: AttrLabelProxy "direction"
textTagEditable :: AttrLabelProxy "editable"
textTagEditableSet :: AttrLabelProxy "editableSet"
textTagFallback :: AttrLabelProxy "fallback"
textTagFallbackSet :: AttrLabelProxy "fallbackSet"
textTagFamily :: AttrLabelProxy "family"
textTagFamilySet :: AttrLabelProxy "familySet"
textTagFont :: AttrLabelProxy "font"
textTagFontDesc :: AttrLabelProxy "fontDesc"
textTagFontFeatures :: AttrLabelProxy "fontFeatures"
textTagFontFeaturesSet :: AttrLabelProxy "fontFeaturesSet"
textTagForeground :: AttrLabelProxy "foreground"
textTagForegroundGdk :: AttrLabelProxy "foregroundGdk"
textTagForegroundRgba :: AttrLabelProxy "foregroundRgba"
textTagForegroundSet :: AttrLabelProxy "foregroundSet"
textTagIndent :: AttrLabelProxy "indent"
textTagIndentSet :: AttrLabelProxy "indentSet"
textTagInvisible :: AttrLabelProxy "invisible"
textTagInvisibleSet :: AttrLabelProxy "invisibleSet"
textTagJustification :: AttrLabelProxy "justification"
textTagJustificationSet :: AttrLabelProxy "justificationSet"
textTagLanguage :: AttrLabelProxy "language"
textTagLanguageSet :: AttrLabelProxy "languageSet"
textTagLeftMargin :: AttrLabelProxy "leftMargin"
textTagLeftMarginSet :: AttrLabelProxy "leftMarginSet"
textTagLetterSpacing :: AttrLabelProxy "letterSpacing"
textTagLetterSpacingSet :: AttrLabelProxy "letterSpacingSet"
textTagName :: AttrLabelProxy "name"
textTagParagraphBackground :: AttrLabelProxy "paragraphBackground"
textTagParagraphBackgroundGdk :: AttrLabelProxy "paragraphBackgroundGdk"
textTagParagraphBackgroundRgba :: AttrLabelProxy "paragraphBackgroundRgba"
textTagParagraphBackgroundSet :: AttrLabelProxy "paragraphBackgroundSet"
textTagPixelsAboveLines :: AttrLabelProxy "pixelsAboveLines"
textTagPixelsAboveLinesSet :: AttrLabelProxy "pixelsAboveLinesSet"
textTagPixelsBelowLines :: AttrLabelProxy "pixelsBelowLines"
textTagPixelsBelowLinesSet :: AttrLabelProxy "pixelsBelowLinesSet"
textTagPixelsInsideWrap :: AttrLabelProxy "pixelsInsideWrap"
textTagPixelsInsideWrapSet :: AttrLabelProxy "pixelsInsideWrapSet"
textTagRightMargin :: AttrLabelProxy "rightMargin"
textTagRightMarginSet :: AttrLabelProxy "rightMarginSet"
textTagRise :: AttrLabelProxy "rise"
textTagRiseSet :: AttrLabelProxy "riseSet"
textTagScale :: AttrLabelProxy "scale"
textTagScaleSet :: AttrLabelProxy "scaleSet"
textTagSize :: AttrLabelProxy "size"
textTagSizePoints :: AttrLabelProxy "sizePoints"
textTagSizeSet :: AttrLabelProxy "sizeSet"
textTagStretch :: AttrLabelProxy "stretch"
textTagStretchSet :: AttrLabelProxy "stretchSet"
textTagStrikethrough :: AttrLabelProxy "strikethrough"
textTagStrikethroughRgba :: AttrLabelProxy "strikethroughRgba"
textTagStrikethroughRgbaSet :: AttrLabelProxy "strikethroughRgbaSet"
textTagStrikethroughSet :: AttrLabelProxy "strikethroughSet"
textTagStyle :: AttrLabelProxy "style"
textTagStyleSet :: AttrLabelProxy "styleSet"
textTagTabs :: AttrLabelProxy "tabs"
textTagTabsSet :: AttrLabelProxy "tabsSet"
textTagUnderline :: AttrLabelProxy "underline"
textTagUnderlineRgba :: AttrLabelProxy "underlineRgba"
textTagUnderlineRgbaSet :: AttrLabelProxy "underlineRgbaSet"
textTagUnderlineSet :: AttrLabelProxy "underlineSet"
textTagVariant :: AttrLabelProxy "variant"
textTagVariantSet :: AttrLabelProxy "variantSet"
textTagWeight :: AttrLabelProxy "weight"
textTagWeightSet :: AttrLabelProxy "weightSet"
textTagWrapMode :: AttrLabelProxy "wrapMode"
textTagWrapModeSet :: AttrLabelProxy "wrapModeSet"
textViewAcceptsTab :: AttrLabelProxy "acceptsTab"
textViewBottomMargin :: AttrLabelProxy "bottomMargin"
textViewBuffer :: AttrLabelProxy "buffer"
textViewCursorVisible :: AttrLabelProxy "cursorVisible"
textViewEditable :: AttrLabelProxy "editable"
textViewImModule :: AttrLabelProxy "imModule"
textViewIndent :: AttrLabelProxy "indent"
textViewInputHints :: AttrLabelProxy "inputHints"
textViewInputPurpose :: AttrLabelProxy "inputPurpose"
textViewJustification :: AttrLabelProxy "justification"
textViewLeftMargin :: AttrLabelProxy "leftMargin"
textViewMonospace :: AttrLabelProxy "monospace"
textViewOverwrite :: AttrLabelProxy "overwrite"
textViewPixelsAboveLines :: AttrLabelProxy "pixelsAboveLines"
textViewPixelsBelowLines :: AttrLabelProxy "pixelsBelowLines"
textViewPixelsInsideWrap :: AttrLabelProxy "pixelsInsideWrap"
textViewPopulateAll :: AttrLabelProxy "populateAll"
textViewRightMargin :: AttrLabelProxy "rightMargin"
textViewTabs :: AttrLabelProxy "tabs"
textViewTopMargin :: AttrLabelProxy "topMargin"
textViewWrapMode :: AttrLabelProxy "wrapMode"
themingEngineName :: AttrLabelProxy "name"
toggleActionActive :: AttrLabelProxy "active"
toggleActionDrawAsRadio :: AttrLabelProxy "drawAsRadio"
toggleButtonActive :: AttrLabelProxy "active"
toggleButtonDrawIndicator :: AttrLabelProxy "drawIndicator"
toggleButtonInconsistent :: AttrLabelProxy "inconsistent"
toggleToolButtonActive :: AttrLabelProxy "active"
toolButtonIconName :: AttrLabelProxy "iconName"
toolButtonIconWidget :: AttrLabelProxy "iconWidget"
toolButtonLabel :: AttrLabelProxy "label"
toolButtonLabelWidget :: AttrLabelProxy "labelWidget"
toolButtonStockId :: AttrLabelProxy "stockId"
toolButtonUseUnderline :: AttrLabelProxy "useUnderline"
toolItemIsImportant :: AttrLabelProxy "isImportant"
toolItemVisibleHorizontal :: AttrLabelProxy "visibleHorizontal"
toolItemVisibleVertical :: AttrLabelProxy "visibleVertical"
toolItemGroupCollapsed :: AttrLabelProxy "collapsed"
toolItemGroupEllipsize :: AttrLabelProxy "ellipsize"
toolItemGroupHeaderRelief :: AttrLabelProxy "headerRelief"
toolItemGroupLabel :: AttrLabelProxy "label"
toolItemGroupLabelWidget :: AttrLabelProxy "labelWidget"
toolPaletteIconSize :: AttrLabelProxy "iconSize"
toolPaletteIconSizeSet :: AttrLabelProxy "iconSizeSet"
toolPaletteToolbarStyle :: AttrLabelProxy "toolbarStyle"
toolbarIconSize :: AttrLabelProxy "iconSize"
toolbarIconSizeSet :: AttrLabelProxy "iconSizeSet"
toolbarShowArrow :: AttrLabelProxy "showArrow"
toolbarToolbarStyle :: AttrLabelProxy "toolbarStyle"
treeModelFilterChildModel :: AttrLabelProxy "childModel"
treeModelFilterVirtualRoot :: AttrLabelProxy "virtualRoot"
treeModelSortModel :: AttrLabelProxy "model"
treeSelectionMode :: AttrLabelProxy "mode"
treeViewActivateOnSingleClick :: AttrLabelProxy "activateOnSingleClick"
treeViewEnableGridLines :: AttrLabelProxy "enableGridLines"
treeViewEnableSearch :: AttrLabelProxy "enableSearch"
treeViewEnableTreeLines :: AttrLabelProxy "enableTreeLines"
treeViewExpanderColumn :: AttrLabelProxy "expanderColumn"
treeViewFixedHeightMode :: AttrLabelProxy "fixedHeightMode"
treeViewHeadersClickable :: AttrLabelProxy "headersClickable"
treeViewHeadersVisible :: AttrLabelProxy "headersVisible"
treeViewHoverExpand :: AttrLabelProxy "hoverExpand"
treeViewHoverSelection :: AttrLabelProxy "hoverSelection"
treeViewLevelIndentation :: AttrLabelProxy "levelIndentation"
treeViewModel :: AttrLabelProxy "model"
treeViewReorderable :: AttrLabelProxy "reorderable"
treeViewRubberBanding :: AttrLabelProxy "rubberBanding"
treeViewRulesHint :: AttrLabelProxy "rulesHint"
treeViewSearchColumn :: AttrLabelProxy "searchColumn"
treeViewShowExpanders :: AttrLabelProxy "showExpanders"
treeViewTooltipColumn :: AttrLabelProxy "tooltipColumn"
treeViewColumnAlignment :: AttrLabelProxy "alignment"
treeViewColumnCellArea :: AttrLabelProxy "cellArea"
treeViewColumnClickable :: AttrLabelProxy "clickable"
treeViewColumnExpand :: AttrLabelProxy "expand"
treeViewColumnFixedWidth :: AttrLabelProxy "fixedWidth"
treeViewColumnMaxWidth :: AttrLabelProxy "maxWidth"
treeViewColumnMinWidth :: AttrLabelProxy "minWidth"
treeViewColumnReorderable :: AttrLabelProxy "reorderable"
treeViewColumnResizable :: AttrLabelProxy "resizable"
treeViewColumnSizing :: AttrLabelProxy "sizing"
treeViewColumnSortColumnId :: AttrLabelProxy "sortColumnId"
treeViewColumnSortIndicator :: AttrLabelProxy "sortIndicator"
treeViewColumnSortOrder :: AttrLabelProxy "sortOrder"
treeViewColumnSpacing :: AttrLabelProxy "spacing"
treeViewColumnTitle :: AttrLabelProxy "title"
treeViewColumnVisible :: AttrLabelProxy "visible"
treeViewColumnWidget :: AttrLabelProxy "widget"
treeViewColumnWidth :: AttrLabelProxy "width"
treeViewColumnXOffset :: AttrLabelProxy "xOffset"
uIManagerAddTearoffs :: AttrLabelProxy "addTearoffs"
uIManagerUi :: AttrLabelProxy "ui"
viewportShadowType :: AttrLabelProxy "shadowType"
volumeButtonUseSymbolic :: AttrLabelProxy "useSymbolic"
widgetAppPaintable :: AttrLabelProxy "appPaintable"
widgetCanDefault :: AttrLabelProxy "canDefault"
widgetCanFocus :: AttrLabelProxy "canFocus"
widgetCompositeChild :: AttrLabelProxy "compositeChild"
widgetDoubleBuffered :: AttrLabelProxy "doubleBuffered"
widgetEvents :: AttrLabelProxy "events"
widgetExpand :: AttrLabelProxy "expand"
widgetFocusOnClick :: AttrLabelProxy "focusOnClick"
widgetHalign :: AttrLabelProxy "halign"
widgetHasTooltip :: AttrLabelProxy "hasTooltip"
widgetHeightRequest :: AttrLabelProxy "heightRequest"
widgetHexpand :: AttrLabelProxy "hexpand"
widgetHexpandSet :: AttrLabelProxy "hexpandSet"
widgetMargin :: AttrLabelProxy "margin"
widgetMarginBottom :: AttrLabelProxy "marginBottom"
widgetMarginEnd :: AttrLabelProxy "marginEnd"
widgetMarginLeft :: AttrLabelProxy "marginLeft"
widgetMarginRight :: AttrLabelProxy "marginRight"
widgetMarginStart :: AttrLabelProxy "marginStart"
widgetMarginTop :: AttrLabelProxy "marginTop"
widgetName :: AttrLabelProxy "name"
widgetNoShowAll :: AttrLabelProxy "noShowAll"
widgetOpacity :: AttrLabelProxy "opacity"
widgetParent :: AttrLabelProxy "parent"
widgetReceivesDefault :: AttrLabelProxy "receivesDefault"
widgetScaleFactor :: AttrLabelProxy "scaleFactor"
widgetSensitive :: AttrLabelProxy "sensitive"
widgetStyle :: AttrLabelProxy "style"
widgetTooltipMarkup :: AttrLabelProxy "tooltipMarkup"
widgetTooltipText :: AttrLabelProxy "tooltipText"
widgetValign :: AttrLabelProxy "valign"
widgetVexpand :: AttrLabelProxy "vexpand"
widgetVexpandSet :: AttrLabelProxy "vexpandSet"
widgetVisible :: AttrLabelProxy "visible"
widgetWidthRequest :: AttrLabelProxy "widthRequest"
widgetWindow :: AttrLabelProxy "window"
windowAcceptFocus :: AttrLabelProxy "acceptFocus"
windowApplication :: AttrLabelProxy "application"
windowAttachedTo :: AttrLabelProxy "attachedTo"
windowDecorated :: AttrLabelProxy "decorated"
windowDefaultHeight :: AttrLabelProxy "defaultHeight"
windowDefaultWidth :: AttrLabelProxy "defaultWidth"
windowDeletable :: AttrLabelProxy "deletable"
windowDestroyWithParent :: AttrLabelProxy "destroyWithParent"
windowFocusOnMap :: AttrLabelProxy "focusOnMap"
windowFocusVisible :: AttrLabelProxy "focusVisible"
windowGravity :: AttrLabelProxy "gravity"
windowHasResizeGrip :: AttrLabelProxy "hasResizeGrip"
windowHideTitlebarWhenMaximized :: AttrLabelProxy "hideTitlebarWhenMaximized"
windowIcon :: AttrLabelProxy "icon"
windowIconName :: AttrLabelProxy "iconName"
windowMnemonicsVisible :: AttrLabelProxy "mnemonicsVisible"
windowModal :: AttrLabelProxy "modal"
windowResizable :: AttrLabelProxy "resizable"
windowResizeGripVisible :: AttrLabelProxy "resizeGripVisible"
windowRole :: AttrLabelProxy "role"
windowScreen :: AttrLabelProxy "screen"
windowSkipPagerHint :: AttrLabelProxy "skipPagerHint"
windowSkipTaskbarHint :: AttrLabelProxy "skipTaskbarHint"
windowStartupId :: AttrLabelProxy "startupId"
windowTitle :: AttrLabelProxy "title"
windowTransientFor :: AttrLabelProxy "transientFor"
windowType :: AttrLabelProxy "type"
windowTypeHint :: AttrLabelProxy "typeHint"
windowUrgencyHint :: AttrLabelProxy "urgencyHint"
windowWindowPosition :: AttrLabelProxy "windowPosition"
accelGroupEntry_accelPathQuark :: AttrLabelProxy "accelPathQuark"
accelGroupEntry_closure :: AttrLabelProxy "closure"
accelGroupEntry_key :: AttrLabelProxy "key"
accelKey_accelFlags :: AttrLabelProxy "accelFlags"
accelKey_accelKey :: AttrLabelProxy "accelKey"
accelKey_accelMods :: AttrLabelProxy "accelMods"
actionEntry_accelerator :: AttrLabelProxy "accelerator"
actionEntry_callback :: AttrLabelProxy "callback"
actionEntry_label :: AttrLabelProxy "label"
actionEntry_name :: AttrLabelProxy "name"
actionEntry_stockId :: AttrLabelProxy "stockId"
actionEntry_tooltip :: AttrLabelProxy "tooltip"
actionableInterface_getActionName :: AttrLabelProxy "getActionName"
actionableInterface_getActionTargetValue :: AttrLabelProxy "getActionTargetValue"
actionableInterface_setActionName :: AttrLabelProxy "setActionName"
actionableInterface_setActionTargetValue :: AttrLabelProxy "setActionTargetValue"
bindingArg_argType :: AttrLabelProxy "argType"
bindingEntry_bindingSet :: AttrLabelProxy "bindingSet"
bindingEntry_destroyed :: AttrLabelProxy "destroyed"
bindingEntry_hashNext :: AttrLabelProxy "hashNext"
bindingEntry_inEmission :: AttrLabelProxy "inEmission"
bindingEntry_keyval :: AttrLabelProxy "keyval"
bindingEntry_marksUnbound :: AttrLabelProxy "marksUnbound"
bindingEntry_modifiers :: AttrLabelProxy "modifiers"
bindingEntry_setNext :: AttrLabelProxy "setNext"
bindingEntry_signals :: AttrLabelProxy "signals"
bindingSet_classBranchPspecs :: AttrLabelProxy "classBranchPspecs"
bindingSet_current :: AttrLabelProxy "current"
bindingSet_entries :: AttrLabelProxy "entries"
bindingSet_parsed :: AttrLabelProxy "parsed"
bindingSet_priority :: AttrLabelProxy "priority"
bindingSet_setName :: AttrLabelProxy "setName"
bindingSet_widgetClassPspecs :: AttrLabelProxy "widgetClassPspecs"
bindingSet_widgetPathPspecs :: AttrLabelProxy "widgetPathPspecs"
bindingSignal_nArgs :: AttrLabelProxy "nArgs"
bindingSignal_next :: AttrLabelProxy "next"
bindingSignal_signalName :: AttrLabelProxy "signalName"
border_bottom :: AttrLabelProxy "bottom"
border_left :: AttrLabelProxy "left"
border_right :: AttrLabelProxy "right"
border_top :: AttrLabelProxy "top"
containerClass_add :: AttrLabelProxy "add"
containerClass_checkResize :: AttrLabelProxy "checkResize"
containerClass_childType :: AttrLabelProxy "childType"
containerClass_compositeName :: AttrLabelProxy "compositeName"
containerClass_forall :: AttrLabelProxy "forall"
containerClass_getChildProperty :: AttrLabelProxy "getChildProperty"
containerClass_getPathForChild :: AttrLabelProxy "getPathForChild"
containerClass_parentClass :: AttrLabelProxy "parentClass"
containerClass_remove :: AttrLabelProxy "remove"
containerClass_setChildProperty :: AttrLabelProxy "setChildProperty"
containerClass_setFocusChild :: AttrLabelProxy "setFocusChild"
fileFilterInfo_contains :: AttrLabelProxy "contains"
fileFilterInfo_displayName :: AttrLabelProxy "displayName"
fileFilterInfo_filename :: AttrLabelProxy "filename"
fileFilterInfo_mimeType :: AttrLabelProxy "mimeType"
fileFilterInfo_uri :: AttrLabelProxy "uri"
fixedChild_widget :: AttrLabelProxy "widget"
fixedChild_x :: AttrLabelProxy "x"
fixedChild_y :: AttrLabelProxy "y"
iMContextInfo_contextId :: AttrLabelProxy "contextId"
iMContextInfo_contextName :: AttrLabelProxy "contextName"
iMContextInfo_defaultLocales :: AttrLabelProxy "defaultLocales"
iMContextInfo_domain :: AttrLabelProxy "domain"
iMContextInfo_domainDirname :: AttrLabelProxy "domainDirname"
mountOperationHandlerIface__parentIface :: AttrLabelProxy "parentIface"
padActionEntry_actionName :: AttrLabelProxy "actionName"
padActionEntry_index :: AttrLabelProxy "index"
padActionEntry_label :: AttrLabelProxy "label"
padActionEntry_mode :: AttrLabelProxy "mode"
padActionEntry_type :: AttrLabelProxy "type"
pageRange_end :: AttrLabelProxy "end"
pageRange_start :: AttrLabelProxy "start"
radioActionEntry_accelerator :: AttrLabelProxy "accelerator"
radioActionEntry_label :: AttrLabelProxy "label"
radioActionEntry_name :: AttrLabelProxy "name"
radioActionEntry_stockId :: AttrLabelProxy "stockId"
radioActionEntry_tooltip :: AttrLabelProxy "tooltip"
radioActionEntry_value :: AttrLabelProxy "value"
rcProperty_origin :: AttrLabelProxy "origin"
rcProperty_propertyName :: AttrLabelProxy "propertyName"
rcProperty_typeName :: AttrLabelProxy "typeName"
rcProperty_value :: AttrLabelProxy "value"
recentData_appExec :: AttrLabelProxy "appExec"
recentData_appName :: AttrLabelProxy "appName"
recentData_description :: AttrLabelProxy "description"
recentData_displayName :: AttrLabelProxy "displayName"
recentData_groups :: AttrLabelProxy "groups"
recentData_isPrivate :: AttrLabelProxy "isPrivate"
recentData_mimeType :: AttrLabelProxy "mimeType"
recentFilterInfo_age :: AttrLabelProxy "age"
recentFilterInfo_applications :: AttrLabelProxy "applications"
recentFilterInfo_contains :: AttrLabelProxy "contains"
recentFilterInfo_displayName :: AttrLabelProxy "displayName"
recentFilterInfo_groups :: AttrLabelProxy "groups"
recentFilterInfo_mimeType :: AttrLabelProxy "mimeType"
recentFilterInfo_uri :: AttrLabelProxy "uri"
requestedSize_data :: AttrLabelProxy "data"
requestedSize_minimumSize :: AttrLabelProxy "minimumSize"
requestedSize_naturalSize :: AttrLabelProxy "naturalSize"
requisition_height :: AttrLabelProxy "height"
requisition_width :: AttrLabelProxy "width"
settingsValue_origin :: AttrLabelProxy "origin"
settingsValue_value :: AttrLabelProxy "value"
stockItem_keyval :: AttrLabelProxy "keyval"
stockItem_label :: AttrLabelProxy "label"
stockItem_modifier :: AttrLabelProxy "modifier"
stockItem_stockId :: AttrLabelProxy "stockId"
stockItem_translationDomain :: AttrLabelProxy "translationDomain"
tableChild_bottomAttach :: AttrLabelProxy "bottomAttach"
tableChild_leftAttach :: AttrLabelProxy "leftAttach"
tableChild_rightAttach :: AttrLabelProxy "rightAttach"
tableChild_topAttach :: AttrLabelProxy "topAttach"
tableChild_widget :: AttrLabelProxy "widget"
tableChild_xexpand :: AttrLabelProxy "xexpand"
tableChild_xfill :: AttrLabelProxy "xfill"
tableChild_xpadding :: AttrLabelProxy "xpadding"
tableChild_xshrink :: AttrLabelProxy "xshrink"
tableChild_yexpand :: AttrLabelProxy "yexpand"
tableChild_yfill :: AttrLabelProxy "yfill"
tableChild_ypadding :: AttrLabelProxy "ypadding"
tableChild_yshrink :: AttrLabelProxy "yshrink"
tableRowCol_allocation :: AttrLabelProxy "allocation"
tableRowCol_empty :: AttrLabelProxy "empty"
tableRowCol_expand :: AttrLabelProxy "expand"
tableRowCol_needExpand :: AttrLabelProxy "needExpand"
tableRowCol_needShrink :: AttrLabelProxy "needShrink"
tableRowCol_requisition :: AttrLabelProxy "requisition"
tableRowCol_shrink :: AttrLabelProxy "shrink"
tableRowCol_spacing :: AttrLabelProxy "spacing"
targetEntry_flags :: AttrLabelProxy "flags"
targetEntry_info :: AttrLabelProxy "info"
targetEntry_target :: AttrLabelProxy "target"
targetPair_flags :: AttrLabelProxy "flags"
targetPair_info :: AttrLabelProxy "info"
targetPair_target :: AttrLabelProxy "target"
textAppearance_bgColor :: AttrLabelProxy "bgColor"
textAppearance_drawBg :: AttrLabelProxy "drawBg"
textAppearance_fgColor :: AttrLabelProxy "fgColor"
textAppearance_insideSelection :: AttrLabelProxy "insideSelection"
textAppearance_isText :: AttrLabelProxy "isText"
textAppearance_rise :: AttrLabelProxy "rise"
textAppearance_strikethrough :: AttrLabelProxy "strikethrough"
textAppearance_underline :: AttrLabelProxy "underline"
textAttributes_appearance :: AttrLabelProxy "appearance"
textAttributes_bgFullHeight :: AttrLabelProxy "bgFullHeight"
textAttributes_direction :: AttrLabelProxy "direction"
textAttributes_editable :: AttrLabelProxy "editable"
textAttributes_font :: AttrLabelProxy "font"
textAttributes_fontScale :: AttrLabelProxy "fontScale"
textAttributes_indent :: AttrLabelProxy "indent"
textAttributes_invisible :: AttrLabelProxy "invisible"
textAttributes_justification :: AttrLabelProxy "justification"
textAttributes_language :: AttrLabelProxy "language"
textAttributes_leftMargin :: AttrLabelProxy "leftMargin"
textAttributes_letterSpacing :: AttrLabelProxy "letterSpacing"
textAttributes_noFallback :: AttrLabelProxy "noFallback"
textAttributes_pixelsAboveLines :: AttrLabelProxy "pixelsAboveLines"
textAttributes_pixelsBelowLines :: AttrLabelProxy "pixelsBelowLines"
textAttributes_pixelsInsideWrap :: AttrLabelProxy "pixelsInsideWrap"
textAttributes_rightMargin :: AttrLabelProxy "rightMargin"
textAttributes_tabs :: AttrLabelProxy "tabs"
textAttributes_wrapMode :: AttrLabelProxy "wrapMode"
toggleActionEntry_accelerator :: AttrLabelProxy "accelerator"
toggleActionEntry_callback :: AttrLabelProxy "callback"
toggleActionEntry_isActive :: AttrLabelProxy "isActive"
toggleActionEntry_label :: AttrLabelProxy "label"
toggleActionEntry_name :: AttrLabelProxy "name"
toggleActionEntry_stockId :: AttrLabelProxy "stockId"
toggleActionEntry_tooltip :: AttrLabelProxy "tooltip"
treeIter_stamp :: AttrLabelProxy "stamp"
treeIter_userData :: AttrLabelProxy "userData"
treeIter_userData2 :: AttrLabelProxy "userData2"
treeIter_userData3 :: AttrLabelProxy "userData3"
widgetClass_activateSignal :: AttrLabelProxy "activateSignal"
widgetClass_adjustBaselineAllocation :: AttrLabelProxy "adjustBaselineAllocation"
widgetClass_adjustBaselineRequest :: AttrLabelProxy "adjustBaselineRequest"
widgetClass_adjustSizeAllocation :: AttrLabelProxy "adjustSizeAllocation"
widgetClass_adjustSizeRequest :: AttrLabelProxy "adjustSizeRequest"
widgetClass_buttonPressEvent :: AttrLabelProxy "buttonPressEvent"
widgetClass_buttonReleaseEvent :: AttrLabelProxy "buttonReleaseEvent"
widgetClass_canActivateAccel :: AttrLabelProxy "canActivateAccel"
widgetClass_childNotify :: AttrLabelProxy "childNotify"
widgetClass_compositedChanged :: AttrLabelProxy "compositedChanged"
widgetClass_computeExpand :: AttrLabelProxy "computeExpand"
widgetClass_configureEvent :: AttrLabelProxy "configureEvent"
widgetClass_damageEvent :: AttrLabelProxy "damageEvent"
widgetClass_deleteEvent :: AttrLabelProxy "deleteEvent"
widgetClass_destroy :: AttrLabelProxy "destroy"
widgetClass_destroyEvent :: AttrLabelProxy "destroyEvent"
widgetClass_directionChanged :: AttrLabelProxy "directionChanged"
widgetClass_dispatchChildPropertiesChanged :: AttrLabelProxy "dispatchChildPropertiesChanged"
widgetClass_dragBegin :: AttrLabelProxy "dragBegin"
widgetClass_dragDataDelete :: AttrLabelProxy "dragDataDelete"
widgetClass_dragDataGet :: AttrLabelProxy "dragDataGet"
widgetClass_dragDataReceived :: AttrLabelProxy "dragDataReceived"
widgetClass_dragDrop :: AttrLabelProxy "dragDrop"
widgetClass_dragEnd :: AttrLabelProxy "dragEnd"
widgetClass_dragFailed :: AttrLabelProxy "dragFailed"
widgetClass_dragLeave :: AttrLabelProxy "dragLeave"
widgetClass_dragMotion :: AttrLabelProxy "dragMotion"
widgetClass_draw :: AttrLabelProxy "draw"
widgetClass_enterNotifyEvent :: AttrLabelProxy "enterNotifyEvent"
widgetClass_event :: AttrLabelProxy "event"
widgetClass_focus :: AttrLabelProxy "focus"
widgetClass_focusInEvent :: AttrLabelProxy "focusInEvent"
widgetClass_focusOutEvent :: AttrLabelProxy "focusOutEvent"
widgetClass_getAccessible :: AttrLabelProxy "getAccessible"
widgetClass_getPreferredHeight :: AttrLabelProxy "getPreferredHeight"
widgetClass_getPreferredHeightAndBaselineForWidth :: AttrLabelProxy "getPreferredHeightAndBaselineForWidth"
widgetClass_getPreferredHeightForWidth :: AttrLabelProxy "getPreferredHeightForWidth"
widgetClass_getPreferredWidth :: AttrLabelProxy "getPreferredWidth"
widgetClass_getPreferredWidthForHeight :: AttrLabelProxy "getPreferredWidthForHeight"
widgetClass_getRequestMode :: AttrLabelProxy "getRequestMode"
widgetClass_grabBrokenEvent :: AttrLabelProxy "grabBrokenEvent"
widgetClass_grabFocus :: AttrLabelProxy "grabFocus"
widgetClass_grabNotify :: AttrLabelProxy "grabNotify"
widgetClass_hide :: AttrLabelProxy "hide"
widgetClass_hierarchyChanged :: AttrLabelProxy "hierarchyChanged"
widgetClass_keyPressEvent :: AttrLabelProxy "keyPressEvent"
widgetClass_keyReleaseEvent :: AttrLabelProxy "keyReleaseEvent"
widgetClass_keynavFailed :: AttrLabelProxy "keynavFailed"
widgetClass_leaveNotifyEvent :: AttrLabelProxy "leaveNotifyEvent"
widgetClass_map :: AttrLabelProxy "map"
widgetClass_mapEvent :: AttrLabelProxy "mapEvent"
widgetClass_mnemonicActivate :: AttrLabelProxy "mnemonicActivate"
widgetClass_motionNotifyEvent :: AttrLabelProxy "motionNotifyEvent"
widgetClass_moveFocus :: AttrLabelProxy "moveFocus"
widgetClass_parentClass :: AttrLabelProxy "parentClass"
widgetClass_parentSet :: AttrLabelProxy "parentSet"
widgetClass_popupMenu :: AttrLabelProxy "popupMenu"
widgetClass_propertyNotifyEvent :: AttrLabelProxy "propertyNotifyEvent"
widgetClass_proximityInEvent :: AttrLabelProxy "proximityInEvent"
widgetClass_proximityOutEvent :: AttrLabelProxy "proximityOutEvent"
widgetClass_queryTooltip :: AttrLabelProxy "queryTooltip"
widgetClass_queueDrawRegion :: AttrLabelProxy "queueDrawRegion"
widgetClass_realize :: AttrLabelProxy "realize"
widgetClass_screenChanged :: AttrLabelProxy "screenChanged"
widgetClass_scrollEvent :: AttrLabelProxy "scrollEvent"
widgetClass_selectionClearEvent :: AttrLabelProxy "selectionClearEvent"
widgetClass_selectionGet :: AttrLabelProxy "selectionGet"
widgetClass_selectionNotifyEvent :: AttrLabelProxy "selectionNotifyEvent"
widgetClass_selectionReceived :: AttrLabelProxy "selectionReceived"
widgetClass_selectionRequestEvent :: AttrLabelProxy "selectionRequestEvent"
widgetClass_show :: AttrLabelProxy "show"
widgetClass_showAll :: AttrLabelProxy "showAll"
widgetClass_showHelp :: AttrLabelProxy "showHelp"
widgetClass_sizeAllocate :: AttrLabelProxy "sizeAllocate"
widgetClass_stateChanged :: AttrLabelProxy "stateChanged"
widgetClass_stateFlagsChanged :: AttrLabelProxy "stateFlagsChanged"
widgetClass_styleSet :: AttrLabelProxy "styleSet"
widgetClass_styleUpdated :: AttrLabelProxy "styleUpdated"
widgetClass_touchEvent :: AttrLabelProxy "touchEvent"
widgetClass_unmap :: AttrLabelProxy "unmap"
widgetClass_unmapEvent :: AttrLabelProxy "unmapEvent"
widgetClass_unrealize :: AttrLabelProxy "unrealize"
widgetClass_visibilityNotifyEvent :: AttrLabelProxy "visibilityNotifyEvent"
widgetClass_windowStateEvent :: AttrLabelProxy "windowStateEvent"
